namespace ext
{
	using System;
	using System.Runtime.CompilerServices;
	using System.Html;
	using System.Collections;
	
	
	/// <definedin>src\core\Element-more.js</definedin>
	/// <definedin>src\core\Element-more.js</definedin>
	/// <definedin>src\core\Element-more.js</definedin>
	/// <definedin>src\core\Element.alignment.js</definedin>
	/// <definedin>src\core\Element.alignment.js</definedin>
	/// <definedin>src\core\Element.alignment.js</definedin>
	/// <definedin>src\core\Element.dd.js</definedin>
	/// <definedin>src\core\Element.dd.js</definedin>
	/// <definedin>src\core\Element.dd.js</definedin>
	/// <definedin>src\core\Element.fx-more.js</definedin>
	/// <definedin>src\core\Element.fx-more.js</definedin>
	/// <definedin>src\core\Element.fx-more.js</definedin>
	/// <definedin>src\core\Element.insertion-more.js</definedin>
	/// <definedin>src\core\Element.insertion-more.js</definedin>
	/// <definedin>src\core\Element.keys.js</definedin>
	/// <definedin>src\core\Element.keys.js</definedin>
	/// <definedin>src\core\Element.keys.js</definedin>
	/// <definedin>src\core\Element.position-more.js</definedin>
	/// <definedin>src\core\Element.position-more.js</definedin>
	/// <definedin>src\core\Element.position-more.js</definedin>
	/// <definedin>src\core\Element.scroll-more.js</definedin>
	/// <definedin>src\core\Element.scroll-more.js</definedin>
	/// <definedin>src\core\Element.scroll-more.js</definedin>
	/// <definedin>src\core\Element.style-more.js</definedin>
	/// <definedin>src\core\Element.style-more.js</definedin>
	/// <definedin>src\core\Element.style-more.js</definedin>
	/// <definedin>src\core\Element.style-more.js</definedin>
	/// <definedin>src\core\Element.style-more.js</definedin>
	/// <definedin>src\core\Element.traversal-more.js</definedin>
	/// <definedin>src\core\Element.traversal-more.js</definedin>
	/// <definedin>src\core\Element.traversal-more.js</definedin>
	/// <definedin>src\ext-core\src\core\Element.fx.js</definedin>
	/// <definedin>src\ext-core\src\core\Element.fx.js</definedin>
	/// <definedin>src\ext-core\src\core\Element.fx.js</definedin>
	/// <definedin>src\ext-core\src\core\Element.fx.js</definedin>
	/// <definedin>src\ext-core\src\core\Element.fx.js</definedin>
	/// <definedin>src\ext-core\src\core\Element.insertion.js</definedin>
	/// <definedin>src\ext-core\src\core\Element.insertion.js</definedin>
	/// <definedin>src\ext-core\src\core\Element.insertion.js</definedin>
	/// <definedin>src\ext-core\src\core\Element.js</definedin>
	/// <definedin>src\ext-core\src\core\Element.position.js</definedin>
	/// <definedin>src\ext-core\src\core\Element.position.js</definedin>
	/// <definedin>src\ext-core\src\core\Element.position.js</definedin>
	/// <definedin>src\ext-core\src\core\Element.position.js</definedin>
	/// <definedin>src\ext-core\src\core\Element.scroll.js</definedin>
	/// <definedin>src\ext-core\src\core\Element.scroll.js</definedin>
	/// <definedin>src\ext-core\src\core\Element.scroll.js</definedin>
	/// <definedin>src\ext-core\src\core\Element.style.js</definedin>
	/// <definedin>src\ext-core\src\core\Element.style.js</definedin>
	/// <definedin>src\ext-core\src\core\Element.traversal.js</definedin>
	/// <definedin>src\ext-core\src\core\Element.traversal.js</definedin>
	[ScriptName("Element")]
	[ScriptNamespace("Ext")]
	[Imported()]
	public partial class Element
	{
		
		#region Fields
		/// <summary>Fires when a mouse click is detected within the element.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("clickEventName")]
		public const string ClickEventName = "click";
		
		/// <summary>Fires when a right click is detected within the element.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("contextmenuEventName")]
		public const string ContextmenuEventName = "contextmenu";
		
		/// <summary>Fires when a mouse double click is detected within the element.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("dblclickEventName")]
		public const string DblclickEventName = "dblclick";
		
		/// <summary>Fires when a mousedown is detected within the element.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("mousedownEventName")]
		public const string MousedownEventName = "mousedown";
		
		/// <summary>Fires when a mouseup is detected within the element.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("mouseupEventName")]
		public const string MouseupEventName = "mouseup";
		
		/// <summary>Fires when a mouseover is detected within the element.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("mouseoverEventName")]
		public const string MouseoverEventName = "mouseover";
		
		/// <summary>Fires when a mousemove is detected with the element.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("mousemoveEventName")]
		public const string MousemoveEventName = "mousemove";
		
		/// <summary>Fires when a mouseout is detected with the element.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("mouseoutEventName")]
		public const string MouseoutEventName = "mouseout";
		
		/// <summary>Fires when the mouse enters the element.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("mouseenterEventName")]
		public const string MouseenterEventName = "mouseenter";
		
		/// <summary>Fires when the mouse leaves the element.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("mouseleaveEventName")]
		public const string MouseleaveEventName = "mouseleave";
		
		/// <summary>Fires when a keypress is detected within the element.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("keypressEventName")]
		public const string KeypressEventName = "keypress";
		
		/// <summary>Fires when a keydown is detected within the element.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("keydownEventName")]
		public const string KeydownEventName = "keydown";
		
		/// <summary>Fires when a keyup is detected within the element.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("keyupEventName")]
		public const string KeyupEventName = "keyup";
		
		/// <summary>Fires when the user agent finishes loading all content within the element. Only supported by window, frames, objects and images.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("loadEventName")]
		public const string LoadEventName = "load";
		
		/// <summary>Fires when the user agent removes all content from a window or frame. For elements, it fires when the target element or any of its content has been removed.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("unloadEventName")]
		public const string UnloadEventName = "unload";
		
		/// <summary>Fires when an object/image is stopped from loading before completely loaded.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("abortEventName")]
		public const string AbortEventName = "abort";
		
		/// <summary>Fires when an object/image/frame cannot be loaded properly.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("errorEventName")]
		public const string ErrorEventName = "error";
		
		/// <summary>Fires when a document view is resized.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("resizeEventName")]
		public const string ResizeEventName = "resize";
		
		/// <summary>Fires when a document view is scrolled.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("scrollEventName")]
		public const string ScrollEventName = "scroll";
		
		/// <summary>Fires when a user selects some text in a text field, including input and textarea.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("selectEventName")]
		public const string SelectEventName = "select";
		
		/// <summary>Fires when a control loses the input focus and its value has been modified since gaining focus.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("changeEventName")]
		public const string ChangeEventName = "change";
		
		/// <summary>Fires when a form is submitted.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("submitEventName")]
		public const string SubmitEventName = "submit";
		
		/// <summary>Fires when a form is reset.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("resetEventName")]
		public const string ResetEventName = "reset";
		
		/// <summary>Fires when an element receives focus either via the pointing device or by tab navigation.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("focusEventName")]
		public const string FocusEventName = "focus";
		
		/// <summary>Fires when an element loses focus either via the pointing device or by tabbing navigation.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("blurEventName")]
		public const string BlurEventName = "blur";
		
		/// <summary>Where supported. Similar to HTML focus event, but can be applied to any focusable element.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("DOMFocusInEventName")]
		public const string DOMFocusInEventName = "DOMFocusIn";
		
		/// <summary>Where supported. Similar to HTML blur event, but can be applied to any focusable element.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("DOMFocusOutEventName")]
		public const string DOMFocusOutEventName = "DOMFocusOut";
		
		/// <summary>Where supported. Fires when an element is activated, for instance, through a mouse click or a keypress.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("DOMActivateEventName")]
		public const string DOMActivateEventName = "DOMActivate";
		
		/// <summary>Where supported. Fires when the subtree is modified.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("DOMSubtreeModifiedEventName")]
		public const string DOMSubtreeModifiedEventName = "DOMSubtreeModified";
		
		/// <summary>Where supported. Fires when a node has been added as a child of another node.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("DOMNodeInsertedEventName")]
		public const string DOMNodeInsertedEventName = "DOMNodeInserted";
		
		/// <summary>Where supported. Fires when a descendant node of the element is removed.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("DOMNodeRemovedEventName")]
		public const string DOMNodeRemovedEventName = "DOMNodeRemoved";
		
		/// <summary>Where supported. Fires when a node is being removed from a document.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("DOMNodeRemovedFromDocumentEventName")]
		public const string DOMNodeRemovedFromDocumentEventName = "DOMNodeRemovedFromDocument";
		
		/// <summary>Where supported. Fires when a node is being inserted into a document.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("DOMNodeInsertedIntoDocumentEventName")]
		public const string DOMNodeInsertedIntoDocumentEventName = "DOMNodeInsertedIntoDocument";
		
		/// <summary>Where supported. Fires when an attribute has been modified.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("DOMAttrModifiedEventName")]
		public const string DOMAttrModifiedEventName = "DOMAttrModified";
		
		/// <summary>Where supported. Fires when the character data has been modified.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("DOMCharacterDataModifiedEventName")]
		public const string DOMCharacterDataModifiedEventName = "DOMCharacterDataModified";
		#endregion
		
		#region Properties
		/// <summary>Visibility mode constant for use with {@link #setVisibilityMode}. Use visibility to hide element</summary>
		/// <definedin>src\ext-core\src\core\Element.fx.js</definedin>
		[ScriptName("VISIBILITY")]
		[IntrinsicProperty()]
		public static System.Number VISIBILITY
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
		}
		
		/// <summary>Visibility mode constant for use with {@link #setVisibilityMode}. Use display to hide element</summary>
		/// <definedin>src\ext-core\src\core\Element.fx.js</definedin>
		[ScriptName("DISPLAY")]
		[IntrinsicProperty()]
		public static System.Number DISPLAY
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
		}
		
		/// <summary>
		/// Visibility mode constant for use with {@link #setVisibilityMode}. Use offsets (x and y positioning offscreen)
		/// to hide element.
		/// </summary>
		/// <definedin>src\ext-core\src\core\Element.fx.js</definedin>
		[ScriptName("OFFSETS")]
		[IntrinsicProperty()]
		public static System.Number OFFSETS
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
		}
		
		/// <summary>Defaults to &apos;x-hide-nosize&apos;</summary>
		/// <definedin>src\ext-core\src\core\Element.fx.js</definedin>
		[ScriptName("visibilityCls")]
		[IntrinsicProperty()]
		public static string VisibilityCls
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>The element&apos;s default display mode (defaults to &quot;&quot;)</summary>
		/// <definedin>src\ext-core\src\core\Element.fx.js</definedin>
		[ScriptName("originalDisplay")]
		[IntrinsicProperty()]
		public string OriginalDisplay
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>The DOM element</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("dom")]
		[IntrinsicProperty()]
		public System.Html.Element Dom
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>The DOM element ID</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("id")]
		[IntrinsicProperty()]
		public string Id
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>The default unit to append to CSS values where a unit isn&apos;t provided (defaults to px).</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("defaultUnit")]
		[IntrinsicProperty()]
		public string DefaultUnit
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		#endregion
		
		#region Methods
		/// <summary>
		/// Create an event handler on this element such that when the event fires and is handled by this element,
		/// it will be relayed to another object (i.e., fired again as if it originated from that object instead).
		/// </summary>
		/// <definedin>src\core\Element-more.js</definedin>
		/// <param name="eventName">The type of event to relay</param>
		/// <param name="object">
		/// Any object that extends {@link Ext.util.Observable} that will provide the context
		/// for firing the relayed event
		/// </param>
		[ScriptName("relayEvent")]
		public void RelayEvent(string eventName, object @object)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Direct access to the Updater {@link Ext.Updater#update} method. The method takes the same object
		/// parameter as {@link Ext.Updater#update}
		/// </summary>
		/// <definedin>src\core\Element-more.js</definedin>
		/// <returns>this</returns>
		[ScriptName("load")]
		public ext.Element LoadMethod()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Gets this element&apos;s {@link Ext.Updater Updater}</summary>
		/// <definedin>src\core\Element-more.js</definedin>
		/// <returns>The Updater</returns>
		[ScriptName("getUpdater")]
		public ext.Updater GetUpdater()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Remove any anchor to this element. See {@link #anchorTo}.</summary>
		/// <definedin>src\core\Element.alignment.js</definedin>
		/// <returns>this</returns>
		[ScriptName("removeAnchor")]
		public ext.Element RemoveAnchor()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Calculates the x, y to center this element on the screen</summary>
		/// <definedin>src\core\Element.alignment.js</definedin>
		/// <returns>The x, y values [x, y]</returns>
		[ScriptName("getCenterXY")]
		public System.Array GetCenterXY()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Initializes a {@link Ext.dd.DD} drag drop object for this element.</summary>
		/// <definedin>src\core\Element.dd.js</definedin>
		/// <param name="group">The group the DD object is member of</param>
		/// <param name="config">The DD config object</param>
		/// <param name="overrides">An object containing methods to override/implement on the DD object</param>
		/// <returns>The DD object</returns>
		[ScriptName("initDD")]
		public ext.dd.DD InitDD(string group, object config, object overrides)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Initializes a {@link Ext.dd.DDProxy} object for this element.</summary>
		/// <definedin>src\core\Element.dd.js</definedin>
		/// <param name="group">The group the DDProxy object is member of</param>
		/// <param name="config">The DDProxy config object</param>
		/// <param name="overrides">An object containing methods to override/implement on the DDProxy object</param>
		/// <returns>The DDProxy object</returns>
		[ScriptName("initDDProxy")]
		public ext.dd.DDProxy InitDDProxy(string group, object config, object overrides)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Initializes a {@link Ext.dd.DDTarget} object for this element.</summary>
		/// <definedin>src\core\Element.dd.js</definedin>
		/// <param name="group">The group the DDTarget object is member of</param>
		/// <param name="config">The DDTarget config object</param>
		/// <param name="overrides">An object containing methods to override/implement on the DDTarget object</param>
		/// <returns>The DDTarget object</returns>
		[ScriptName("initDDTarget")]
		public ext.dd.DDTarget InitDDTarget(string group, object config, object overrides)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns true if display is not &quot;none&quot;</summary>
		/// <definedin>src\core\Element.fx-more.js</definedin>
		[ScriptName("isDisplayed")]
		public bool IsDisplayed()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Removes a previously applied mask.</summary>
		/// <definedin>src\core\Element.fx-more.js</definedin>
		[ScriptName("unmask")]
		public void Unmask()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns true if this element is masked</summary>
		/// <definedin>src\core\Element.fx-more.js</definedin>
		[ScriptName("isMasked")]
		public bool IsMasked()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Creates an iframe shim for this element to keep selects and other windowed objects from
		/// showing through.
		/// </summary>
		/// <definedin>src\core\Element.fx-more.js</definedin>
		/// <returns>The new shim element</returns>
		[ScriptName("createShim")]
		public ext.Element CreateShim()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Creates a KeyMap for this element</summary>
		/// <definedin>src\core\Element.keys.js</definedin>
		/// <param name="config">The KeyMap config. See {@link Ext.KeyMap} for more details</param>
		/// <returns>The KeyMap created</returns>
		[ScriptName("addKeyMap")]
		public ext.KeyMap AddKeyMap(object config)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Quick set left and top adding default units</summary>
		/// <definedin>src\core\Element.position-more.js</definedin>
		/// <param name="left">The left CSS property value</param>
		/// <param name="top">The top CSS property value</param>
		/// <returns>this</returns>
		[ScriptName("setLeftTop")]
		public ext.Element SetLeftTop(string left, string top)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Returns the region of the given element.
		/// The element must be part of the DOM tree to have a region (display:none or elements not appended return false).
		/// </summary>
		/// <definedin>src\core\Element.position-more.js</definedin>
		/// <returns>A Ext.lib.Region containing &quot;top, left, bottom, right&quot; member data.</returns>
		[ScriptName("getRegion")]
		public ext.lib.Region GetRegion()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Returns either the offsetHeight or the height of this element based on CSS height adjusted by padding or borders
		/// when needed to simulate offsetHeight when offsets aren&apos;t available. This may not work on display:none elements
		/// if a height has not been set using CSS.
		/// </summary>
		/// <definedin>src\core\Element.style-more.js</definedin>
		[ScriptName("getComputedHeight")]
		public System.Number GetComputedHeight()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Returns either the offsetWidth or the width of this element based on CSS width adjusted by padding or borders
		/// when needed to simulate offsetWidth when offsets aren&apos;t available. This may not work on display:none elements
		/// if a width has not been set using CSS.
		/// </summary>
		/// <definedin>src\core\Element.style-more.js</definedin>
		[ScriptName("getComputedWidth")]
		public System.Number GetComputedWidth()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Returns the sum width of the padding and borders for the passed &quot;sides&quot;. See getBorderWidth()
		/// for more information about the sides.
		/// </summary>
		/// <definedin>src\core\Element.style-more.js</definedin>
		/// <param name="sides"></param>
		[ScriptName("getFrameWidth")]
		public System.Number GetFrameWidth(string sides)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Sets up event handlers to add and remove a css class when the mouse is over this element</summary>
		/// <definedin>src\core\Element.style-more.js</definedin>
		/// <param name="className"></param>
		/// <returns>this</returns>
		[ScriptName("addClassOnOver")]
		public ext.Element AddClassOnOver(string className)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Sets up event handlers to add and remove a css class when this element has the focus</summary>
		/// <definedin>src\core\Element.style-more.js</definedin>
		/// <param name="className"></param>
		/// <returns>this</returns>
		[ScriptName("addClassOnFocus")]
		public ext.Element AddClassOnFocus(string className)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Sets up event handlers to add and remove a css class when the mouse is down and then up on this element (a click effect)</summary>
		/// <definedin>src\core\Element.style-more.js</definedin>
		/// <param name="className"></param>
		/// <returns>this</returns>
		[ScriptName("addClassOnClick")]
		public ext.Element AddClassOnClick(string className)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Forces the browser to repaint this element</summary>
		/// <definedin>src\core\Element.style-more.js</definedin>
		/// <returns>this</returns>
		[ScriptName("repaint")]
		public ext.Element Repaint()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Disables text selection for this element (normalized across browsers)</summary>
		/// <definedin>src\core\Element.style-more.js</definedin>
		/// <returns>this</returns>
		[ScriptName("unselectable")]
		public ext.Element Unselectable()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Sets the element&apos;s visibility mode. When setVisible() is called it
		/// will use this to determine whether to set the visibility or the display property.
		/// </summary>
		/// <definedin>src\ext-core\src\core\Element.fx.js</definedin>
		/// <param name="visMode">Ext.Element.VISIBILITY or Ext.Element.DISPLAY</param>
		/// <returns>this</returns>
		[ScriptName("setVisibilityMode")]
		public ext.Element SetVisibilityMode(System.Number visMode)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Sets the CSS display property. Uses originalDisplay if the specified value is a boolean true.</summary>
		/// <definedin>src\ext-core\src\core\Element.fx.js</definedin>
		/// <param name="value">Boolean value to display the element using its default display, or a string to set the display directly.</param>
		/// <returns>this</returns>
		[ScriptName("setDisplayed")]
		public ext.Element SetDisplayed(object value)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Appends this element to the passed element</summary>
		/// <definedin>src\ext-core\src\core\Element.insertion.js</definedin>
		/// <param name="el">The new parent element</param>
		/// <returns>this</returns>
		[ScriptName("appendTo")]
		public ext.Element AppendTo(object el)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Inserts this element before the passed element in the DOM</summary>
		/// <definedin>src\ext-core\src\core\Element.insertion.js</definedin>
		/// <param name="el">The element before which this element will be inserted</param>
		/// <returns>this</returns>
		[ScriptName("insertBefore")]
		public ext.Element InsertBefore(object el)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Inserts this element after the passed element in the DOM</summary>
		/// <definedin>src\ext-core\src\core\Element.insertion.js</definedin>
		/// <param name="el">The element to insert after</param>
		/// <returns>this</returns>
		[ScriptName("insertAfter")]
		public ext.Element InsertAfter(object el)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Inserts (or creates) an element (or DomHelper config) as the first child of this element</summary>
		/// <definedin>src\ext-core\src\core\Element.insertion.js</definedin>
		/// <param name="el">The id or element to insert or a DomHelper config to create and insert</param>
		/// <returns>The new child</returns>
		[ScriptName("insertFirst")]
		public ext.Element InsertFirst(object el)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Replaces the passed element with this element</summary>
		/// <definedin>src\ext-core\src\core\Element.insertion.js</definedin>
		/// <param name="el">The element to replace</param>
		/// <returns>this</returns>
		[ScriptName("replace")]
		public ext.Element Replace(object el)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Replaces this element with the passed element</summary>
		/// <definedin>src\ext-core\src\core\Element.insertion.js</definedin>
		/// <param name="el">The new element or a DomHelper config of an element to create</param>
		/// <returns>this</returns>
		[ScriptName("replaceWith")]
		public ext.Element ReplaceWith(object el)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns true if this element matches the passed simple selector (e.g. div.some-class or span:first-child)</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		/// <param name="selector">The simple selector to test</param>
		/// <returns>True if this element matches the selector, else false</returns>
		[ScriptName("is")]
		public bool Is(string selector)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Tries to blur the element. Any exceptions are caught and ignored.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		/// <returns>this</returns>
		[ScriptName("blur")]
		public ext.Element BlurMethod()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns the value of the &quot;value&quot; attribute</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		/// <param name="asNumber">true to parse the value as a number</param>
		[ScriptName("getValue")]
		public ext.auto.System_String_Or_System_Number GetValue(bool asNumber)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Removes an event handler from this element. The shorthand version {@link #un} is equivalent.
		/// Note: if a scope was explicitly specified when {@link #addListener adding} the
		/// listener, the same scope must be specified here.
		/// Example:
		/// 
		/// el.removeListener(&apos;click&apos;, this.handlerFn);
		/// // or
		/// el.un(&apos;click&apos;, this.handlerFn);
		/// </summary>
		/// <htmlSummary>
		/// Removes an event handler from this element. The shorthand version {@link #un} is equivalent.
		/// &lt;b&gt;Note&lt;/b&gt;: if a &lt;i&gt;scope&lt;/i&gt; was explicitly specified when {@link #addListener adding} the
		/// listener, the same scope must be specified here.
		/// Example:
		/// &lt;pre&gt;&lt;code&gt;
		/// el.removeListener(&apos;click&apos;, this.handlerFn);
		/// // or
		/// el.un(&apos;click&apos;, this.handlerFn);
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		/// <param name="eventName">The name of the event from which to remove the handler.</param>
		/// <param name="fn">The handler function to remove. &lt;b&gt;This must be a reference to the function passed into the {@link #addListener} call.&lt;/b&gt;</param>
		/// <param name="scope">
		/// If a scope (&lt;b&gt;<c>this</c>&lt;/b&gt; reference) was specified when the listener was added,
		/// then this must refer to the same object.
		/// </param>
		/// <returns>this</returns>
		[ScriptName("removeListener")]
		public ext.Element RemoveListener(string eventName, System.Delegate fn, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Removes all previous added listeners from this element</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		/// <returns>this</returns>
		[ScriptName("removeAllListeners")]
		public ext.Element RemoveAllListeners()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Recursively removes all previous added listeners from this element and its children</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		/// <returns>this</returns>
		[ScriptName("purgeAllListeners")]
		public ext.Element PurgeAllListeners()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Updates the innerHTML of this Element
		/// from a specified URL. Note that this is subject to the Same Origin Policy  Updating innerHTML of an element will not execute embedded &amp;lt;script&gt; elements. This is a browser restriction.
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Updates the &lt;a href=&quot;http://developer.mozilla.org/en/DOM/element.innerHTML&quot;&gt;innerHTML&lt;/a&gt; of this Element
		/// from a specified URL. Note that this is subject to the &lt;a href=&quot;http://en.wikipedia.org/wiki/Same_origin_policy&quot;&gt;Same Origin Policy&lt;/a&gt;&lt;/p&gt;
		/// &lt;p&gt;Updating innerHTML of an element will &lt;b&gt;not&lt;/b&gt; execute embedded &lt;tt&gt;&amp;lt;script&gt;&lt;/tt&gt; elements. This is a browser restriction.&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		/// <param name="options">
		/// Either a sring containing the URL from which to load the HTML, or an {@link Ext.Ajax#request} options object specifying
		/// exactly how to request the HTML.
		/// </param>
		/// <returns>this</returns>
		[ScriptName("load")]
		public ext.Element LoadMethod(object options)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Tests various css rules/browsers to determine if this element uses a border box</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("isBorderBox")]
		public bool IsBorderBox()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Removes this element&apos;s dom reference. Note that event and cache removal is handled at {@link Ext#removeNode}</summary>
		/// <htmlSummary>&lt;p&gt;Removes this element&apos;s dom reference. Note that event and cache removal is handled at {@link Ext#removeNode}&lt;/p&gt;</htmlSummary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("remove")]
		public void Remove()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns the value of a namespaced attribute from the element&apos;s underlying DOM node.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		/// <deprecated>Deprecated</deprecated>
		/// <param name="namespace">The namespace in which to look for the attribute</param>
		/// <param name="name">The attribute name</param>
		/// <returns>The attribute value</returns>
		[ScriptName("getAttributeNS")]
		public string GetAttributeNS(string @namespace, string name)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Removes an event handler from this element (see {@link #removeListener} for additional notes).</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		/// <param name="eventName">The name of the event from which to remove the handler.</param>
		/// <param name="fn">The handler function to remove. &lt;b&gt;This must be a reference to the function passed into the {@link #addListener} call.&lt;/b&gt;</param>
		/// <param name="scope">
		/// If a scope (&lt;b&gt;<c>this</c>&lt;/b&gt; reference) was specified when the listener was added,
		/// then this must refer to the same object.
		/// </param>
		/// <returns>this</returns>
		[ScriptName("un")]
		public static ext.Element Un(string eventName, System.Delegate fn, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Retrieves Ext.Element objects.
		/// This method does not retrieve {@link Ext.Component Component}s. This method
		/// retrieves Ext.Element objects which encapsulate DOM elements. To retrieve a Component by
		/// its ID, use {@link Ext.ComponentMgr#get}.  Uses simple caching to consistently return the same object. Automatically fixes if an
		/// object was recreated with the same id via AJAX or DOM.
		/// </summary>
		/// <htmlSummary>
		/// Retrieves Ext.Element objects.
		/// &lt;p&gt;&lt;b&gt;This method does not retrieve {@link Ext.Component Component}s.&lt;/b&gt; This method
		/// retrieves Ext.Element objects which encapsulate DOM elements. To retrieve a Component by
		/// its ID, use {@link Ext.ComponentMgr#get}.&lt;/p&gt;
		/// &lt;p&gt;Uses simple caching to consistently return the same object. Automatically fixes if an
		/// object was recreated with the same id via AJAX or DOM.&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		/// <param name="el">The id of the node, a DOM Node or an existing Element.</param>
		/// <returns>The Element object (or null if no matching element was found)</returns>
		[ScriptName("get")]
		public static ext.Element Get(object el)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Gets the current X position of the element based on page coordinates. Element must be part of the DOM tree to have page coordinates (display:none or elements not appended return false).</summary>
		/// <definedin>src\ext-core\src\core\Element.position.js</definedin>
		/// <returns>The X position of the element</returns>
		[ScriptName("getX")]
		public System.Number GetX()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Gets the current Y position of the element based on page coordinates. Element must be part of the DOM tree to have page coordinates (display:none or elements not appended return false).</summary>
		/// <definedin>src\ext-core\src\core\Element.position.js</definedin>
		/// <returns>The Y position of the element</returns>
		[ScriptName("getY")]
		public System.Number GetY()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Gets the current position of the element based on page coordinates. Element must be part of the DOM tree to have page coordinates (display:none or elements not appended return false).</summary>
		/// <definedin>src\ext-core\src\core\Element.position.js</definedin>
		/// <returns>The XY position of the element</returns>
		[ScriptName("getXY")]
		public System.Array GetXY()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns the offsets of this element from the passed element. Both element must be part of the DOM tree and not have display:none to have page coordinates.</summary>
		/// <definedin>src\ext-core\src\core\Element.position.js</definedin>
		/// <param name="element">The element to get the offsets from.</param>
		/// <returns>The XY page offsets (e.g. [100, -200])</returns>
		[ScriptName("getOffsetsTo")]
		public System.Array GetOffsetsTo(object element)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Sets the element&apos;s left position directly using CSS style (instead of {@link #setX}).</summary>
		/// <definedin>src\ext-core\src\core\Element.position.js</definedin>
		/// <param name="left">The left CSS property value</param>
		/// <returns>this</returns>
		[ScriptName("setLeft")]
		public ext.Element SetLeft(string left)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Sets the element&apos;s top position directly using CSS style (instead of {@link #setY}).</summary>
		/// <definedin>src\ext-core\src\core\Element.position.js</definedin>
		/// <param name="top">The top CSS property value</param>
		/// <returns>this</returns>
		[ScriptName("setTop")]
		public ext.Element SetTop(string top)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Sets the element&apos;s CSS right style.</summary>
		/// <definedin>src\ext-core\src\core\Element.position.js</definedin>
		/// <param name="right">The right CSS property value</param>
		/// <returns>this</returns>
		[ScriptName("setRight")]
		public ext.Element SetRight(string right)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Sets the element&apos;s CSS bottom style.</summary>
		/// <definedin>src\ext-core\src\core\Element.position.js</definedin>
		/// <param name="bottom">The bottom CSS property value</param>
		/// <returns>this</returns>
		[ScriptName("setBottom")]
		public ext.Element SetBottom(string bottom)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Gets the left X coordinate</summary>
		/// <definedin>src\ext-core\src\core\Element.position.js</definedin>
		/// <param name="local">True to get the local css position instead of page coordinate</param>
		[ScriptName("getLeft")]
		public System.Number GetLeft(bool local)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Gets the right X coordinate of the element (element X position + element width)</summary>
		/// <definedin>src\ext-core\src\core\Element.position.js</definedin>
		/// <param name="local">True to get the local css position instead of page coordinate</param>
		[ScriptName("getRight")]
		public System.Number GetRight(bool local)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Gets the top Y coordinate</summary>
		/// <definedin>src\ext-core\src\core\Element.position.js</definedin>
		/// <param name="local">True to get the local css position instead of page coordinate</param>
		[ScriptName("getTop")]
		public System.Number GetTop(bool local)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Gets the bottom Y coordinate of the element (element Y position + element height)</summary>
		/// <definedin>src\ext-core\src\core\Element.position.js</definedin>
		/// <param name="local">True to get the local css position instead of page coordinate</param>
		[ScriptName("getBottom")]
		public System.Number GetBottom(bool local)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Gets an object with all CSS positioning properties. Useful along with setPostioning to get
		/// snapshot before performing an update and then restoring the element.
		/// </summary>
		/// <definedin>src\ext-core\src\core\Element.position.js</definedin>
		[ScriptName("getPositioning")]
		public object GetPositioning()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Set positioning with an object returned by getPositioning().</summary>
		/// <definedin>src\ext-core\src\core\Element.position.js</definedin>
		/// <param name="posCfg"></param>
		/// <returns>this</returns>
		[ScriptName("setPositioning")]
		public ext.Element SetPositioning(object posCfg)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns true if this element is scrollable.</summary>
		/// <definedin>src\ext-core\src\core\Element.scroll.js</definedin>
		[ScriptName("isScrollable")]
		public bool IsScrollable()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns the current scroll position of the element.</summary>
		/// <definedin>src\ext-core\src\core\Element.scroll.js</definedin>
		/// <returns>An object containing the scroll position in the format {left: (scrollLeft), top: (scrollTop)}</returns>
		[ScriptName("getScroll")]
		public object GetScroll()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Toggles the specified CSS class on this element (removes it if it already exists, otherwise adds it).</summary>
		/// <definedin>src\ext-core\src\core\Element.style.js</definedin>
		/// <param name="className">The CSS class to toggle</param>
		/// <returns>this</returns>
		[ScriptName("toggleClass")]
		public ext.Element ToggleClass(string className)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Checks if the specified CSS class exists on this element&apos;s DOM node.</summary>
		/// <definedin>src\ext-core\src\core\Element.style.js</definedin>
		/// <param name="className">The CSS class to check for</param>
		/// <returns>True if the class exists, else false</returns>
		[ScriptName("hasClass")]
		public bool HasClass(string className)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Replaces a CSS class on the element with another. If the old name does not exist, the new name will simply be added.</summary>
		/// <definedin>src\ext-core\src\core\Element.style.js</definedin>
		/// <param name="oldClassName">The CSS class to replace</param>
		/// <param name="newClassName">The replacement CSS class</param>
		/// <returns>this</returns>
		[ScriptName("replaceClass")]
		public ext.Element ReplaceClass(string oldClassName, string newClassName)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Normalizes currentStyle and computedStyle.</summary>
		/// <definedin>src\ext-core\src\core\Element.style.js</definedin>
		/// <param name="property">The style property whose value is returned.</param>
		/// <returns>The current value of the style property for this element.</returns>
		[ScriptName("getStyle")]
		public string GetStyle(string property)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Clears any opacity settings from this element. Required in some cases for IE.</summary>
		/// <definedin>src\ext-core\src\core\Element.style.js</definedin>
		/// <returns>this</returns>
		[ScriptName("clearOpacity")]
		public ext.Element ClearOpacity()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Gets the width of the border(s) for the specified side(s)</summary>
		/// <definedin>src\ext-core\src\core\Element.style.js</definedin>
		/// <param name="side">
		/// Can be t, l, r, b or any combination of those to add multiple values. For example,
		/// passing &lt;tt&gt;&apos;lr&apos;&lt;/tt&gt; would get the border &lt;b&gt;&lt;u&gt;l&lt;/u&gt;&lt;/b&gt;eft width + the border &lt;b&gt;&lt;u&gt;r&lt;/u&gt;&lt;/b&gt;ight width.
		/// </param>
		/// <returns>The width of the sides passed added together</returns>
		[ScriptName("getBorderWidth")]
		public System.Number GetBorderWidth(string side)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Gets the width of the padding(s) for the specified side(s)</summary>
		/// <definedin>src\ext-core\src\core\Element.style.js</definedin>
		/// <param name="side">
		/// Can be t, l, r, b or any combination of those to add multiple values. For example,
		/// passing &lt;tt&gt;&apos;lr&apos;&lt;/tt&gt; would get the padding &lt;b&gt;&lt;u&gt;l&lt;/u&gt;&lt;/b&gt;eft + the padding &lt;b&gt;&lt;u&gt;r&lt;/u&gt;&lt;/b&gt;ight.
		/// </param>
		/// <returns>The padding of the sides passed added together</returns>
		[ScriptName("getPadding")]
		public System.Number GetPadding(string side)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Store the current overflow setting and clip overflow on the element - use {@link #unclip} to remove</summary>
		/// <htmlSummary>Store the current overflow setting and clip overflow on the element - use &lt;tt&gt;{@link #unclip}&lt;/tt&gt; to remove</htmlSummary>
		/// <definedin>src\ext-core\src\core\Element.style.js</definedin>
		/// <returns>this</returns>
		[ScriptName("clip")]
		public ext.Element Clip()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Return clipping (overflow) to original clipping before {@link #clip} was called</summary>
		/// <htmlSummary>Return clipping (overflow) to original clipping before &lt;tt&gt;{@link #clip}&lt;/tt&gt; was called</htmlSummary>
		/// <definedin>src\ext-core\src\core\Element.style.js</definedin>
		/// <returns>this</returns>
		[ScriptName("unclip")]
		public ext.Element Unclip()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Selects child nodes based on the passed CSS selector (the selector should not contain an id).</summary>
		/// <definedin>src\ext-core\src\core\Element.traversal.js</definedin>
		/// <param name="selector">The CSS selector</param>
		/// <returns>An array of the matched nodes</returns>
		[ScriptName("query")]
		public System.Array Query(string selector)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Selects elements based on the passed CSS selector to enable {@link Ext.Element Element} methods
		/// to be applied to many related elements in one statement through the returned {@link Ext.CompositeElement CompositeElement} or
		/// {@link Ext.CompositeElementLite CompositeElementLite} object.
		/// </summary>
		/// <definedin>src\core\CompositeElement.js</definedin>
		/// <param name="selector">The CSS selector or an array of elements</param>
		/// <param name="unique">true to create a unique Ext.Element for each element (defaults to a shared flyweight object)</param>
		/// <param name="root">The root element of the query or id of the root</param>
		[ScriptName("select")]
		public static ext.auto.ext_CompositeElementLite_Or_ext_CompositeElement SelectMethod(string selector, bool unique, System.Html.Element root)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Selects elements based on the passed CSS selector to enable {@link Ext.Element Element} methods
		/// to be applied to many related elements in one statement through the returned {@link Ext.CompositeElement CompositeElement} or
		/// {@link Ext.CompositeElementLite CompositeElementLite} object.
		/// </summary>
		/// <definedin>src\core\CompositeElement.js</definedin>
		/// <param name="selector">The CSS selector or an array of elements</param>
		/// <param name="unique">true to create a unique Ext.Element for each element (defaults to a shared flyweight object)</param>
		/// <param name="root">The root element of the query or id of the root</param>
		[ScriptName("select")]
		public static ext.auto.ext_CompositeElementLite_Or_ext_CompositeElement SelectMethod(string selector, bool unique, string root)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Selects elements based on the passed CSS selector to enable {@link Ext.Element Element} methods
		/// to be applied to many related elements in one statement through the returned {@link Ext.CompositeElement CompositeElement} or
		/// {@link Ext.CompositeElementLite CompositeElementLite} object.
		/// </summary>
		/// <definedin>src\core\CompositeElement.js</definedin>
		/// <param name="selector">The CSS selector or an array of elements</param>
		/// <param name="unique">true to create a unique Ext.Element for each element (defaults to a shared flyweight object)</param>
		/// <param name="root">The root element of the query or id of the root</param>
		[ScriptName("select")]
		public static ext.auto.ext_CompositeElementLite_Or_ext_CompositeElement SelectMethod(System.Array selector, bool unique, System.Html.Element root)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Selects elements based on the passed CSS selector to enable {@link Ext.Element Element} methods
		/// to be applied to many related elements in one statement through the returned {@link Ext.CompositeElement CompositeElement} or
		/// {@link Ext.CompositeElementLite CompositeElementLite} object.
		/// </summary>
		/// <definedin>src\core\CompositeElement.js</definedin>
		/// <param name="selector">The CSS selector or an array of elements</param>
		/// <param name="unique">true to create a unique Ext.Element for each element (defaults to a shared flyweight object)</param>
		/// <param name="root">The root element of the query or id of the root</param>
		[ScriptName("select")]
		public static ext.auto.ext_CompositeElementLite_Or_ext_CompositeElement SelectMethod(System.Array selector, bool unique, string root)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Selects elements based on the passed CSS selector to enable {@link Ext.Element Element} methods
		/// to be applied to many related elements in one statement through the returned {@link Ext.CompositeElement CompositeElement} or
		/// {@link Ext.CompositeElementLite CompositeElementLite} object.
		/// </summary>
		/// <definedin>src\core\CompositeElement.js</definedin>
		/// <param name="selector">The CSS selector or an array of elements</param>
		/// <param name="unique">true to create a unique Ext.Element for each element (defaults to a shared flyweight object)</param>
		[ScriptName("select")]
		public static ext.auto.ext_CompositeElementLite_Or_ext_CompositeElement SelectMethod(System.Array selector, bool unique)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Stops the specified event(s) from bubbling and optionally prevents the default action</summary>
		/// <definedin>src\core\Element-more.js</definedin>
		/// <param name="eventName">an event / array of events to stop from bubbling</param>
		/// <param name="preventDefault">true to prevent the default action too</param>
		/// <returns>this</returns>
		[ScriptName("swallowEvent")]
		public ext.Element SwallowEvent(string eventName, bool preventDefault)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Stops the specified event(s) from bubbling and optionally prevents the default action</summary>
		/// <definedin>src\core\Element-more.js</definedin>
		/// <param name="eventName">an event / array of events to stop from bubbling</param>
		/// <param name="preventDefault">true to prevent the default action too</param>
		/// <returns>this</returns>
		[ScriptName("swallowEvent")]
		public ext.Element SwallowEvent(System.Array eventName, bool preventDefault)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Stops the specified event(s) from bubbling and optionally prevents the default action</summary>
		/// <definedin>src\core\Element-more.js</definedin>
		/// <param name="eventName">an event / array of events to stop from bubbling</param>
		/// <returns>this</returns>
		[ScriptName("swallowEvent")]
		public ext.Element SwallowEvent(string eventName)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Stops the specified event(s) from bubbling and optionally prevents the default action</summary>
		/// <definedin>src\core\Element-more.js</definedin>
		/// <param name="eventName">an event / array of events to stop from bubbling</param>
		/// <returns>this</returns>
		[ScriptName("swallowEvent")]
		public ext.Element SwallowEvent(System.Array eventName)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Removes worthless text nodes</summary>
		/// <definedin>src\core\Element-more.js</definedin>
		/// <param name="forceReclean">
		/// By default the element
		/// keeps track if it has been cleaned already so
		/// you can call this over and over. However, if you update the element and
		/// need to force a reclean, you can pass true.
		/// </param>
		[ScriptName("clean")]
		public void Clean(bool forceReclean)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Removes worthless text nodes</summary>
		/// <definedin>src\core\Element-more.js</definedin>
		[ScriptName("clean")]
		public void Clean()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Update the innerHTML of this element, optionally searching for and processing scripts</summary>
		/// <definedin>src\core\Element-more.js</definedin>
		/// <param name="html">The new HTML</param>
		/// <param name="loadScripts">True to look for and process scripts (defaults to false)</param>
		/// <param name="callback">For async script loading you can be notified when the update completes</param>
		/// <returns>this</returns>
		[ScriptName("update")]
		public ext.Element Update(string html, bool loadScripts, System.Delegate callback)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Update the innerHTML of this element, optionally searching for and processing scripts</summary>
		/// <definedin>src\core\Element-more.js</definedin>
		/// <param name="html">The new HTML</param>
		/// <param name="loadScripts">True to look for and process scripts (defaults to false)</param>
		/// <returns>this</returns>
		[ScriptName("update")]
		public ext.Element Update(string html, bool loadScripts)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Creates a proxy element of this element</summary>
		/// <definedin>src\core\Element-more.js</definedin>
		/// <param name="config">The class name of the proxy element or a DomHelper config object</param>
		/// <param name="renderTo">The element or element id to render the proxy to (defaults to document.body)</param>
		/// <param name="matchBox">True to align and size the proxy to this element now (defaults to false)</param>
		/// <returns>The new proxy element</returns>
		[ScriptName("createProxy")]
		public ext.Element CreateProxy(string config, string renderTo, bool matchBox)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Creates a proxy element of this element</summary>
		/// <definedin>src\core\Element-more.js</definedin>
		/// <param name="config">The class name of the proxy element or a DomHelper config object</param>
		/// <param name="renderTo">The element or element id to render the proxy to (defaults to document.body)</param>
		/// <param name="matchBox">True to align and size the proxy to this element now (defaults to false)</param>
		/// <returns>The new proxy element</returns>
		[ScriptName("createProxy")]
		public ext.Element CreateProxy(string config, System.Html.Element renderTo, bool matchBox)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Creates a proxy element of this element</summary>
		/// <definedin>src\core\Element-more.js</definedin>
		/// <param name="config">The class name of the proxy element or a DomHelper config object</param>
		/// <param name="renderTo">The element or element id to render the proxy to (defaults to document.body)</param>
		/// <param name="matchBox">True to align and size the proxy to this element now (defaults to false)</param>
		/// <returns>The new proxy element</returns>
		[ScriptName("createProxy")]
		public ext.Element CreateProxy(object config, string renderTo, bool matchBox)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Creates a proxy element of this element</summary>
		/// <definedin>src\core\Element-more.js</definedin>
		/// <param name="config">The class name of the proxy element or a DomHelper config object</param>
		/// <param name="renderTo">The element or element id to render the proxy to (defaults to document.body)</param>
		/// <param name="matchBox">True to align and size the proxy to this element now (defaults to false)</param>
		/// <returns>The new proxy element</returns>
		[ScriptName("createProxy")]
		public ext.Element CreateProxy(object config, System.Html.Element renderTo, bool matchBox)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Creates a proxy element of this element</summary>
		/// <definedin>src\core\Element-more.js</definedin>
		/// <param name="config">The class name of the proxy element or a DomHelper config object</param>
		/// <param name="renderTo">The element or element id to render the proxy to (defaults to document.body)</param>
		/// <returns>The new proxy element</returns>
		[ScriptName("createProxy")]
		public ext.Element CreateProxy(string config, string renderTo)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Creates a proxy element of this element</summary>
		/// <definedin>src\core\Element-more.js</definedin>
		/// <param name="config">The class name of the proxy element or a DomHelper config object</param>
		/// <param name="renderTo">The element or element id to render the proxy to (defaults to document.body)</param>
		/// <returns>The new proxy element</returns>
		[ScriptName("createProxy")]
		public ext.Element CreateProxy(string config, System.Html.Element renderTo)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Creates a proxy element of this element</summary>
		/// <definedin>src\core\Element-more.js</definedin>
		/// <param name="config">The class name of the proxy element or a DomHelper config object</param>
		/// <param name="renderTo">The element or element id to render the proxy to (defaults to document.body)</param>
		/// <returns>The new proxy element</returns>
		[ScriptName("createProxy")]
		public ext.Element CreateProxy(object config, string renderTo)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Creates a proxy element of this element</summary>
		/// <definedin>src\core\Element-more.js</definedin>
		/// <param name="config">The class name of the proxy element or a DomHelper config object</param>
		/// <param name="renderTo">The element or element id to render the proxy to (defaults to document.body)</param>
		/// <returns>The new proxy element</returns>
		[ScriptName("createProxy")]
		public ext.Element CreateProxy(object config, System.Html.Element renderTo)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Creates a proxy element of this element</summary>
		/// <definedin>src\core\Element-more.js</definedin>
		/// <param name="config">The class name of the proxy element or a DomHelper config object</param>
		/// <returns>The new proxy element</returns>
		[ScriptName("createProxy")]
		public ext.Element CreateProxy(string config)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Creates a proxy element of this element</summary>
		/// <definedin>src\core\Element-more.js</definedin>
		/// <param name="config">The class name of the proxy element or a DomHelper config object</param>
		/// <returns>The new proxy element</returns>
		[ScriptName("createProxy")]
		public ext.Element CreateProxy(object config)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Gets the x,y coordinates specified by the anchor position on the element.</summary>
		/// <definedin>src\core\Element.alignment.js</definedin>
		/// <param name="anchor">
		/// The specified anchor position (defaults to &quot;c&quot;). See {@link #alignTo}
		/// for details on supported anchor positions.
		/// </param>
		/// <param name="local">
		/// True to get the local (element top/left-relative) anchor position instead
		/// of page coordinates
		/// </param>
		/// <param name="size">
		/// An object containing the size to use for calculating anchor position
		/// {width: (target width), height: (target height)} (defaults to the element&apos;s current size)
		/// </param>
		/// <returns>[x, y] An array containing the element&apos;s x and y coordinates</returns>
		[ScriptName("getAnchorXY")]
		public System.Array GetAnchorXY(string anchor, bool local, object size)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Gets the x,y coordinates specified by the anchor position on the element.</summary>
		/// <definedin>src\core\Element.alignment.js</definedin>
		/// <param name="anchor">
		/// The specified anchor position (defaults to &quot;c&quot;). See {@link #alignTo}
		/// for details on supported anchor positions.
		/// </param>
		/// <param name="local">
		/// True to get the local (element top/left-relative) anchor position instead
		/// of page coordinates
		/// </param>
		/// <returns>[x, y] An array containing the element&apos;s x and y coordinates</returns>
		[ScriptName("getAnchorXY")]
		public System.Array GetAnchorXY(string anchor, bool local)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Gets the x,y coordinates specified by the anchor position on the element.</summary>
		/// <definedin>src\core\Element.alignment.js</definedin>
		/// <param name="anchor">
		/// The specified anchor position (defaults to &quot;c&quot;). See {@link #alignTo}
		/// for details on supported anchor positions.
		/// </param>
		/// <returns>[x, y] An array containing the element&apos;s x and y coordinates</returns>
		[ScriptName("getAnchorXY")]
		public System.Array GetAnchorXY(string anchor)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Gets the x,y coordinates specified by the anchor position on the element.</summary>
		/// <definedin>src\core\Element.alignment.js</definedin>
		/// <returns>[x, y] An array containing the element&apos;s x and y coordinates</returns>
		[ScriptName("getAnchorXY")]
		public System.Array GetAnchorXY()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Anchors an element to another element and realigns it when the window is resized.</summary>
		/// <definedin>src\core\Element.alignment.js</definedin>
		/// <param name="element">The element to align to.</param>
		/// <param name="position">The position to align to.</param>
		/// <param name="offsets">Offset the positioning by [x, y]</param>
		/// <param name="animate">True for the default animation or a standard Element animation config object</param>
		/// <param name="monitorScroll">
		/// True to monitor body scroll and reposition. If this parameter
		/// is a number, it is used as the buffer delay (defaults to 50ms).
		/// </param>
		/// <param name="callback">The function to call after the animation finishes</param>
		/// <returns>this</returns>
		[ScriptName("anchorTo")]
		public ext.Element AnchorTo(object element, string position, System.Array offsets, bool animate, bool monitorScroll, System.Delegate callback)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Anchors an element to another element and realigns it when the window is resized.</summary>
		/// <definedin>src\core\Element.alignment.js</definedin>
		/// <param name="element">The element to align to.</param>
		/// <param name="position">The position to align to.</param>
		/// <param name="offsets">Offset the positioning by [x, y]</param>
		/// <param name="animate">True for the default animation or a standard Element animation config object</param>
		/// <param name="monitorScroll">
		/// True to monitor body scroll and reposition. If this parameter
		/// is a number, it is used as the buffer delay (defaults to 50ms).
		/// </param>
		/// <param name="callback">The function to call after the animation finishes</param>
		/// <returns>this</returns>
		[ScriptName("anchorTo")]
		public ext.Element AnchorTo(object element, string position, System.Array offsets, bool animate, System.Number monitorScroll, System.Delegate callback)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Anchors an element to another element and realigns it when the window is resized.</summary>
		/// <definedin>src\core\Element.alignment.js</definedin>
		/// <param name="element">The element to align to.</param>
		/// <param name="position">The position to align to.</param>
		/// <param name="offsets">Offset the positioning by [x, y]</param>
		/// <param name="animate">True for the default animation or a standard Element animation config object</param>
		/// <param name="monitorScroll">
		/// True to monitor body scroll and reposition. If this parameter
		/// is a number, it is used as the buffer delay (defaults to 50ms).
		/// </param>
		/// <param name="callback">The function to call after the animation finishes</param>
		/// <returns>this</returns>
		[ScriptName("anchorTo")]
		public ext.Element AnchorTo(object element, string position, System.Array offsets, object animate, bool monitorScroll, System.Delegate callback)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Anchors an element to another element and realigns it when the window is resized.</summary>
		/// <definedin>src\core\Element.alignment.js</definedin>
		/// <param name="element">The element to align to.</param>
		/// <param name="position">The position to align to.</param>
		/// <param name="offsets">Offset the positioning by [x, y]</param>
		/// <param name="animate">True for the default animation or a standard Element animation config object</param>
		/// <param name="monitorScroll">
		/// True to monitor body scroll and reposition. If this parameter
		/// is a number, it is used as the buffer delay (defaults to 50ms).
		/// </param>
		/// <param name="callback">The function to call after the animation finishes</param>
		/// <returns>this</returns>
		[ScriptName("anchorTo")]
		public ext.Element AnchorTo(object element, string position, System.Array offsets, object animate, System.Number monitorScroll, System.Delegate callback)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Gets the x,y coordinates to align this element with another element. See {@link #alignTo} for more info on the
		/// supported position values.
		/// </summary>
		/// <definedin>src\core\Element.alignment.js</definedin>
		/// <param name="element">The element to align to.</param>
		/// <param name="position">(optional, defaults to &quot;tl-bl?&quot;) The position to align to.</param>
		/// <param name="offsets">Offset the positioning by [x, y]</param>
		/// <returns>[x, y]</returns>
		[ScriptName("getAlignToXY")]
		public System.Array GetAlignToXY(object element, string position, System.Array offsets)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Gets the x,y coordinates to align this element with another element. See {@link #alignTo} for more info on the
		/// supported position values.
		/// </summary>
		/// <definedin>src\core\Element.alignment.js</definedin>
		/// <param name="element">The element to align to.</param>
		/// <param name="position">(optional, defaults to &quot;tl-bl?&quot;) The position to align to.</param>
		/// <returns>[x, y]</returns>
		[ScriptName("getAlignToXY")]
		public System.Array GetAlignToXY(object element, string position)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Aligns this element with another element relative to the specified anchor points. If the other element is the
		/// document it aligns it to the viewport.
		/// The position parameter is optional, and can be specified in any one of the following formats:
		///  Blank: Defaults to aligning the element&apos;s top-left corner to the target&apos;s bottom-left corner (&quot;tl-bl&quot;).  One anchor (deprecated): The passed anchor position is used as the target element&apos;s anchor point.
		/// The element being aligned will position its top-left corner (tl) to that point. This method has been
		/// deprecated in favor of the newer two anchor syntax below.  Two anchors: If two values from the table below are passed separated by a dash, the first value is used as the
		/// element&apos;s anchor point, and the second value is used as the target&apos;s anchor point.  
		/// In addition to the anchor points, the position parameter also supports the &quot;?&quot; character. If &quot;?&quot; is passed at the end of
		/// the position string, the element will attempt to align as...
		/// </summary>
		/// <htmlSummary>
		/// Aligns this element with another element relative to the specified anchor points. If the other element is the
		/// document it aligns it to the viewport.
		/// The position parameter is optional, and can be specified in any one of the following formats:
		/// &lt;ul&gt;
		/// &lt;li&gt;&lt;b&gt;Blank&lt;/b&gt;: Defaults to aligning the element&apos;s top-left corner to the target&apos;s bottom-left corner (&quot;tl-bl&quot;).&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;One anchor (deprecated)&lt;/b&gt;: The passed anchor position is used as the target element&apos;s anchor point.
		/// The element being aligned will position its top-left corner (tl) to that point. &lt;i&gt;This method has been
		/// deprecated in favor of the newer two anchor syntax below&lt;/i&gt;.&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;Two anchors&lt;/b&gt;: If two values from the table below are passed separated by a dash, the first value is used as the
		/// element&apos;s anchor point, and the second value is used as the target&apos;s anchor point.&lt;/li&gt;
		/// &lt;/ul&gt;
		/// In addition to the anchor points, the position parameter also supports the &quot;?&quot; character. If &quot;?&quot; is passed at the end of
		/// the position string, the element will attempt to align as specified, but the position will be adjusted to constrain to
		/// the viewport if necessary. Note that the element being aligned might be swapped to align to a different position than
		/// that specified in order to enforce the viewport constraints.
		/// Following are all of the supported anchor positions:
		/// &lt;pre&gt;
		/// Value Description
		/// ----- -----------------------------
		/// tl The top left corner (default)
		/// t The center of the top edge
		/// tr The top right corner
		/// l The center of the left edge
		/// c In the center of the element
		/// r The center of the right edge
		/// bl The bottom left corner
		/// b The center of the bottom edge
		/// br The bottom right corner
		/// &lt;/pre&gt;
		/// Example Usage:
		/// &lt;pre&gt;&lt;code&gt;
		/// // align el to other-el using the default positioning (&quot;tl-bl&quot;, non-constrained)
		/// el.alignTo(&quot;other-el&quot;);
		///
		/// // align the top left corner of el with the top right corner of other-el (constrained to viewport)
		/// el.alignTo(&quot;other-el&quot;, &quot;tr?&quot;);
		///
		/// // align the bottom right corner of el with the center left edge of other-el
		/// el.alignTo(&quot;other-el&quot;, &quot;br-l?&quot;);
		///
		/// // align the center of el with the bottom left corner of other-el and
		/// // adjust the x position by -6 pixels (and the y position by 0)
		/// el.alignTo(&quot;other-el&quot;, &quot;c-bl&quot;, [-6, 0]);
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\core\Element.alignment.js</definedin>
		/// <param name="element">The element to align to.</param>
		/// <param name="position">(optional, defaults to &quot;tl-bl?&quot;) The position to align to.</param>
		/// <param name="offsets">Offset the positioning by [x, y]</param>
		/// <param name="animate">true for the default animation or a standard Element animation config object</param>
		/// <returns>this</returns>
		[ScriptName("alignTo")]
		public ext.Element AlignTo(object element, string position, System.Array offsets, bool animate)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Aligns this element with another element relative to the specified anchor points. If the other element is the
		/// document it aligns it to the viewport.
		/// The position parameter is optional, and can be specified in any one of the following formats:
		///  Blank: Defaults to aligning the element&apos;s top-left corner to the target&apos;s bottom-left corner (&quot;tl-bl&quot;).  One anchor (deprecated): The passed anchor position is used as the target element&apos;s anchor point.
		/// The element being aligned will position its top-left corner (tl) to that point. This method has been
		/// deprecated in favor of the newer two anchor syntax below.  Two anchors: If two values from the table below are passed separated by a dash, the first value is used as the
		/// element&apos;s anchor point, and the second value is used as the target&apos;s anchor point.  
		/// In addition to the anchor points, the position parameter also supports the &quot;?&quot; character. If &quot;?&quot; is passed at the end of
		/// the position string, the element will attempt to align as...
		/// </summary>
		/// <htmlSummary>
		/// Aligns this element with another element relative to the specified anchor points. If the other element is the
		/// document it aligns it to the viewport.
		/// The position parameter is optional, and can be specified in any one of the following formats:
		/// &lt;ul&gt;
		/// &lt;li&gt;&lt;b&gt;Blank&lt;/b&gt;: Defaults to aligning the element&apos;s top-left corner to the target&apos;s bottom-left corner (&quot;tl-bl&quot;).&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;One anchor (deprecated)&lt;/b&gt;: The passed anchor position is used as the target element&apos;s anchor point.
		/// The element being aligned will position its top-left corner (tl) to that point. &lt;i&gt;This method has been
		/// deprecated in favor of the newer two anchor syntax below&lt;/i&gt;.&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;Two anchors&lt;/b&gt;: If two values from the table below are passed separated by a dash, the first value is used as the
		/// element&apos;s anchor point, and the second value is used as the target&apos;s anchor point.&lt;/li&gt;
		/// &lt;/ul&gt;
		/// In addition to the anchor points, the position parameter also supports the &quot;?&quot; character. If &quot;?&quot; is passed at the end of
		/// the position string, the element will attempt to align as specified, but the position will be adjusted to constrain to
		/// the viewport if necessary. Note that the element being aligned might be swapped to align to a different position than
		/// that specified in order to enforce the viewport constraints.
		/// Following are all of the supported anchor positions:
		/// &lt;pre&gt;
		/// Value Description
		/// ----- -----------------------------
		/// tl The top left corner (default)
		/// t The center of the top edge
		/// tr The top right corner
		/// l The center of the left edge
		/// c In the center of the element
		/// r The center of the right edge
		/// bl The bottom left corner
		/// b The center of the bottom edge
		/// br The bottom right corner
		/// &lt;/pre&gt;
		/// Example Usage:
		/// &lt;pre&gt;&lt;code&gt;
		/// // align el to other-el using the default positioning (&quot;tl-bl&quot;, non-constrained)
		/// el.alignTo(&quot;other-el&quot;);
		///
		/// // align the top left corner of el with the top right corner of other-el (constrained to viewport)
		/// el.alignTo(&quot;other-el&quot;, &quot;tr?&quot;);
		///
		/// // align the bottom right corner of el with the center left edge of other-el
		/// el.alignTo(&quot;other-el&quot;, &quot;br-l?&quot;);
		///
		/// // align the center of el with the bottom left corner of other-el and
		/// // adjust the x position by -6 pixels (and the y position by 0)
		/// el.alignTo(&quot;other-el&quot;, &quot;c-bl&quot;, [-6, 0]);
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\core\Element.alignment.js</definedin>
		/// <param name="element">The element to align to.</param>
		/// <param name="position">(optional, defaults to &quot;tl-bl?&quot;) The position to align to.</param>
		/// <param name="offsets">Offset the positioning by [x, y]</param>
		/// <param name="animate">true for the default animation or a standard Element animation config object</param>
		/// <returns>this</returns>
		[ScriptName("alignTo")]
		public ext.Element AlignTo(object element, string position, System.Array offsets, object animate)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Aligns this element with another element relative to the specified anchor points. If the other element is the
		/// document it aligns it to the viewport.
		/// The position parameter is optional, and can be specified in any one of the following formats:
		///  Blank: Defaults to aligning the element&apos;s top-left corner to the target&apos;s bottom-left corner (&quot;tl-bl&quot;).  One anchor (deprecated): The passed anchor position is used as the target element&apos;s anchor point.
		/// The element being aligned will position its top-left corner (tl) to that point. This method has been
		/// deprecated in favor of the newer two anchor syntax below.  Two anchors: If two values from the table below are passed separated by a dash, the first value is used as the
		/// element&apos;s anchor point, and the second value is used as the target&apos;s anchor point.  
		/// In addition to the anchor points, the position parameter also supports the &quot;?&quot; character. If &quot;?&quot; is passed at the end of
		/// the position string, the element will attempt to align as...
		/// </summary>
		/// <htmlSummary>
		/// Aligns this element with another element relative to the specified anchor points. If the other element is the
		/// document it aligns it to the viewport.
		/// The position parameter is optional, and can be specified in any one of the following formats:
		/// &lt;ul&gt;
		/// &lt;li&gt;&lt;b&gt;Blank&lt;/b&gt;: Defaults to aligning the element&apos;s top-left corner to the target&apos;s bottom-left corner (&quot;tl-bl&quot;).&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;One anchor (deprecated)&lt;/b&gt;: The passed anchor position is used as the target element&apos;s anchor point.
		/// The element being aligned will position its top-left corner (tl) to that point. &lt;i&gt;This method has been
		/// deprecated in favor of the newer two anchor syntax below&lt;/i&gt;.&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;Two anchors&lt;/b&gt;: If two values from the table below are passed separated by a dash, the first value is used as the
		/// element&apos;s anchor point, and the second value is used as the target&apos;s anchor point.&lt;/li&gt;
		/// &lt;/ul&gt;
		/// In addition to the anchor points, the position parameter also supports the &quot;?&quot; character. If &quot;?&quot; is passed at the end of
		/// the position string, the element will attempt to align as specified, but the position will be adjusted to constrain to
		/// the viewport if necessary. Note that the element being aligned might be swapped to align to a different position than
		/// that specified in order to enforce the viewport constraints.
		/// Following are all of the supported anchor positions:
		/// &lt;pre&gt;
		/// Value Description
		/// ----- -----------------------------
		/// tl The top left corner (default)
		/// t The center of the top edge
		/// tr The top right corner
		/// l The center of the left edge
		/// c In the center of the element
		/// r The center of the right edge
		/// bl The bottom left corner
		/// b The center of the bottom edge
		/// br The bottom right corner
		/// &lt;/pre&gt;
		/// Example Usage:
		/// &lt;pre&gt;&lt;code&gt;
		/// // align el to other-el using the default positioning (&quot;tl-bl&quot;, non-constrained)
		/// el.alignTo(&quot;other-el&quot;);
		///
		/// // align the top left corner of el with the top right corner of other-el (constrained to viewport)
		/// el.alignTo(&quot;other-el&quot;, &quot;tr?&quot;);
		///
		/// // align the bottom right corner of el with the center left edge of other-el
		/// el.alignTo(&quot;other-el&quot;, &quot;br-l?&quot;);
		///
		/// // align the center of el with the bottom left corner of other-el and
		/// // adjust the x position by -6 pixels (and the y position by 0)
		/// el.alignTo(&quot;other-el&quot;, &quot;c-bl&quot;, [-6, 0]);
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\core\Element.alignment.js</definedin>
		/// <param name="element">The element to align to.</param>
		/// <param name="position">(optional, defaults to &quot;tl-bl?&quot;) The position to align to.</param>
		/// <param name="offsets">Offset the positioning by [x, y]</param>
		/// <returns>this</returns>
		[ScriptName("alignTo")]
		public ext.Element AlignTo(object element, string position, System.Array offsets)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Aligns this element with another element relative to the specified anchor points. If the other element is the
		/// document it aligns it to the viewport.
		/// The position parameter is optional, and can be specified in any one of the following formats:
		///  Blank: Defaults to aligning the element&apos;s top-left corner to the target&apos;s bottom-left corner (&quot;tl-bl&quot;).  One anchor (deprecated): The passed anchor position is used as the target element&apos;s anchor point.
		/// The element being aligned will position its top-left corner (tl) to that point. This method has been
		/// deprecated in favor of the newer two anchor syntax below.  Two anchors: If two values from the table below are passed separated by a dash, the first value is used as the
		/// element&apos;s anchor point, and the second value is used as the target&apos;s anchor point.  
		/// In addition to the anchor points, the position parameter also supports the &quot;?&quot; character. If &quot;?&quot; is passed at the end of
		/// the position string, the element will attempt to align as...
		/// </summary>
		/// <htmlSummary>
		/// Aligns this element with another element relative to the specified anchor points. If the other element is the
		/// document it aligns it to the viewport.
		/// The position parameter is optional, and can be specified in any one of the following formats:
		/// &lt;ul&gt;
		/// &lt;li&gt;&lt;b&gt;Blank&lt;/b&gt;: Defaults to aligning the element&apos;s top-left corner to the target&apos;s bottom-left corner (&quot;tl-bl&quot;).&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;One anchor (deprecated)&lt;/b&gt;: The passed anchor position is used as the target element&apos;s anchor point.
		/// The element being aligned will position its top-left corner (tl) to that point. &lt;i&gt;This method has been
		/// deprecated in favor of the newer two anchor syntax below&lt;/i&gt;.&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;Two anchors&lt;/b&gt;: If two values from the table below are passed separated by a dash, the first value is used as the
		/// element&apos;s anchor point, and the second value is used as the target&apos;s anchor point.&lt;/li&gt;
		/// &lt;/ul&gt;
		/// In addition to the anchor points, the position parameter also supports the &quot;?&quot; character. If &quot;?&quot; is passed at the end of
		/// the position string, the element will attempt to align as specified, but the position will be adjusted to constrain to
		/// the viewport if necessary. Note that the element being aligned might be swapped to align to a different position than
		/// that specified in order to enforce the viewport constraints.
		/// Following are all of the supported anchor positions:
		/// &lt;pre&gt;
		/// Value Description
		/// ----- -----------------------------
		/// tl The top left corner (default)
		/// t The center of the top edge
		/// tr The top right corner
		/// l The center of the left edge
		/// c In the center of the element
		/// r The center of the right edge
		/// bl The bottom left corner
		/// b The center of the bottom edge
		/// br The bottom right corner
		/// &lt;/pre&gt;
		/// Example Usage:
		/// &lt;pre&gt;&lt;code&gt;
		/// // align el to other-el using the default positioning (&quot;tl-bl&quot;, non-constrained)
		/// el.alignTo(&quot;other-el&quot;);
		///
		/// // align the top left corner of el with the top right corner of other-el (constrained to viewport)
		/// el.alignTo(&quot;other-el&quot;, &quot;tr?&quot;);
		///
		/// // align the bottom right corner of el with the center left edge of other-el
		/// el.alignTo(&quot;other-el&quot;, &quot;br-l?&quot;);
		///
		/// // align the center of el with the bottom left corner of other-el and
		/// // adjust the x position by -6 pixels (and the y position by 0)
		/// el.alignTo(&quot;other-el&quot;, &quot;c-bl&quot;, [-6, 0]);
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\core\Element.alignment.js</definedin>
		/// <param name="element">The element to align to.</param>
		/// <param name="position">(optional, defaults to &quot;tl-bl?&quot;) The position to align to.</param>
		/// <returns>this</returns>
		[ScriptName("alignTo")]
		public ext.Element AlignTo(object element, string position)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Centers the Element in either the viewport, or another Element.</summary>
		/// <definedin>src\core\Element.alignment.js</definedin>
		/// <param name="centerIn">The element in which to center the element.</param>
		[ScriptName("center")]
		public void Center(object centerIn)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Centers the Element in either the viewport, or another Element.</summary>
		/// <definedin>src\core\Element.alignment.js</definedin>
		[ScriptName("center")]
		public void Center()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Checks whether the element is currently visible using both visibility and display properties.</summary>
		/// <definedin>src\core\Element.fx-more.js</definedin>
		/// <param name="deep">True to walk the dom and see if parent elements are hidden (defaults to false)</param>
		/// <returns>True if the element is currently visible, else false</returns>
		[ScriptName("isVisible")]
		public bool IsVisible(bool deep)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Convenience method for setVisibilityMode(Element.DISPLAY)</summary>
		/// <definedin>src\core\Element.fx-more.js</definedin>
		/// <param name="display">What to set display to when visible</param>
		/// <returns>this</returns>
		[ScriptName("enableDisplayMode")]
		public ext.Element EnableDisplayMode(string display)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Convenience method for setVisibilityMode(Element.DISPLAY)</summary>
		/// <definedin>src\core\Element.fx-more.js</definedin>
		/// <returns>this</returns>
		[ScriptName("enableDisplayMode")]
		public ext.Element EnableDisplayMode()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Puts a mask over this element to disable user interaction. Requires core.css.
		/// This method can only be applied to elements which accept child nodes.
		/// </summary>
		/// <definedin>src\core\Element.fx-more.js</definedin>
		/// <param name="msg">A message to display in the mask</param>
		/// <param name="msgCls">A css class to apply to the msg element</param>
		/// <returns>The mask element</returns>
		[ScriptName("mask")]
		public ext.Element Mask(string msg, string msgCls)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Puts a mask over this element to disable user interaction. Requires core.css.
		/// This method can only be applied to elements which accept child nodes.
		/// </summary>
		/// <definedin>src\core\Element.fx-more.js</definedin>
		/// <param name="msg">A message to display in the mask</param>
		/// <returns>The mask element</returns>
		[ScriptName("mask")]
		public ext.Element Mask(string msg)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Puts a mask over this element to disable user interaction. Requires core.css.
		/// This method can only be applied to elements which accept child nodes.
		/// </summary>
		/// <definedin>src\core\Element.fx-more.js</definedin>
		/// <returns>The mask element</returns>
		[ScriptName("mask")]
		public ext.Element Mask()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Inserts (or creates) the passed element (or DomHelper config) as a sibling of this element</summary>
		/// <definedin>src\core\Element.insertion-more.js</definedin>
		/// <param name="el">The id, element to insert or a DomHelper config to create and insert *or* an array of any of those.</param>
		/// <param name="where">&apos;before&apos; or &apos;after&apos; defaults to before</param>
		/// <param name="returnDom">True to return the raw DOM element instead of Ext.Element</param>
		/// <returns>The inserted Element. If an array is passed, the last inserted element is returned.</returns>
		[ScriptName("insertSibling")]
		public ext.Element InsertSibling(object el, string where, bool returnDom)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Inserts (or creates) the passed element (or DomHelper config) as a sibling of this element</summary>
		/// <definedin>src\core\Element.insertion-more.js</definedin>
		/// <param name="el">The id, element to insert or a DomHelper config to create and insert *or* an array of any of those.</param>
		/// <param name="where">&apos;before&apos; or &apos;after&apos; defaults to before</param>
		/// <param name="returnDom">True to return the raw DOM element instead of Ext.Element</param>
		/// <returns>The inserted Element. If an array is passed, the last inserted element is returned.</returns>
		[ScriptName("insertSibling")]
		public ext.Element InsertSibling(System.Array el, string where, bool returnDom)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Inserts (or creates) the passed element (or DomHelper config) as a sibling of this element</summary>
		/// <definedin>src\core\Element.insertion-more.js</definedin>
		/// <param name="el">The id, element to insert or a DomHelper config to create and insert *or* an array of any of those.</param>
		/// <param name="where">&apos;before&apos; or &apos;after&apos; defaults to before</param>
		/// <returns>The inserted Element. If an array is passed, the last inserted element is returned.</returns>
		[ScriptName("insertSibling")]
		public ext.Element InsertSibling(object el, string where)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Inserts (or creates) the passed element (or DomHelper config) as a sibling of this element</summary>
		/// <definedin>src\core\Element.insertion-more.js</definedin>
		/// <param name="el">The id, element to insert or a DomHelper config to create and insert *or* an array of any of those.</param>
		/// <param name="where">&apos;before&apos; or &apos;after&apos; defaults to before</param>
		/// <returns>The inserted Element. If an array is passed, the last inserted element is returned.</returns>
		[ScriptName("insertSibling")]
		public ext.Element InsertSibling(System.Array el, string where)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Inserts (or creates) the passed element (or DomHelper config) as a sibling of this element</summary>
		/// <definedin>src\core\Element.insertion-more.js</definedin>
		/// <param name="el">The id, element to insert or a DomHelper config to create and insert *or* an array of any of those.</param>
		/// <returns>The inserted Element. If an array is passed, the last inserted element is returned.</returns>
		[ScriptName("insertSibling")]
		public ext.Element InsertSibling(object el)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Inserts (or creates) the passed element (or DomHelper config) as a sibling of this element</summary>
		/// <definedin>src\core\Element.insertion-more.js</definedin>
		/// <param name="el">The id, element to insert or a DomHelper config to create and insert *or* an array of any of those.</param>
		/// <returns>The inserted Element. If an array is passed, the last inserted element is returned.</returns>
		[ScriptName("insertSibling")]
		public ext.Element InsertSibling(System.Array el)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Convenience method for constructing a KeyMap</summary>
		/// <definedin>src\core\Element.keys.js</definedin>
		/// <param name="key">
		/// Either a string with the keys to listen for, the numeric key code, array of key codes or an object with the following options:
		/// <c>{key: (number or array), shift: (true/false), ctrl: (true/false), alt: (true/false)}</c>
		/// </param>
		/// <param name="fn">The function to call</param>
		/// <param name="scope">The scope (<c>this</c> reference) in which the specified function is executed. Defaults to this Element.</param>
		/// <returns>The KeyMap created</returns>
		[ScriptName("addKeyListener")]
		public ext.KeyMap AddKeyListener(System.Number key, System.Delegate fn, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Convenience method for constructing a KeyMap</summary>
		/// <definedin>src\core\Element.keys.js</definedin>
		/// <param name="key">
		/// Either a string with the keys to listen for, the numeric key code, array of key codes or an object with the following options:
		/// <c>{key: (number or array), shift: (true/false), ctrl: (true/false), alt: (true/false)}</c>
		/// </param>
		/// <param name="fn">The function to call</param>
		/// <param name="scope">The scope (<c>this</c> reference) in which the specified function is executed. Defaults to this Element.</param>
		/// <returns>The KeyMap created</returns>
		[ScriptName("addKeyListener")]
		public ext.KeyMap AddKeyListener(System.Array key, System.Delegate fn, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Convenience method for constructing a KeyMap</summary>
		/// <definedin>src\core\Element.keys.js</definedin>
		/// <param name="key">
		/// Either a string with the keys to listen for, the numeric key code, array of key codes or an object with the following options:
		/// <c>{key: (number or array), shift: (true/false), ctrl: (true/false), alt: (true/false)}</c>
		/// </param>
		/// <param name="fn">The function to call</param>
		/// <param name="scope">The scope (<c>this</c> reference) in which the specified function is executed. Defaults to this Element.</param>
		/// <returns>The KeyMap created</returns>
		[ScriptName("addKeyListener")]
		public ext.KeyMap AddKeyListener(object key, System.Delegate fn, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Convenience method for constructing a KeyMap</summary>
		/// <definedin>src\core\Element.keys.js</definedin>
		/// <param name="key">
		/// Either a string with the keys to listen for, the numeric key code, array of key codes or an object with the following options:
		/// <c>{key: (number or array), shift: (true/false), ctrl: (true/false), alt: (true/false)}</c>
		/// </param>
		/// <param name="fn">The function to call</param>
		/// <param name="scope">The scope (<c>this</c> reference) in which the specified function is executed. Defaults to this Element.</param>
		/// <returns>The KeyMap created</returns>
		[ScriptName("addKeyListener")]
		public ext.KeyMap AddKeyListener(string key, System.Delegate fn, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Convenience method for constructing a KeyMap</summary>
		/// <definedin>src\core\Element.keys.js</definedin>
		/// <param name="key">
		/// Either a string with the keys to listen for, the numeric key code, array of key codes or an object with the following options:
		/// <c>{key: (number or array), shift: (true/false), ctrl: (true/false), alt: (true/false)}</c>
		/// </param>
		/// <param name="fn">The function to call</param>
		/// <returns>The KeyMap created</returns>
		[ScriptName("addKeyListener")]
		public ext.KeyMap AddKeyListener(System.Number key, System.Delegate fn)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Convenience method for constructing a KeyMap</summary>
		/// <definedin>src\core\Element.keys.js</definedin>
		/// <param name="key">
		/// Either a string with the keys to listen for, the numeric key code, array of key codes or an object with the following options:
		/// <c>{key: (number or array), shift: (true/false), ctrl: (true/false), alt: (true/false)}</c>
		/// </param>
		/// <param name="fn">The function to call</param>
		/// <returns>The KeyMap created</returns>
		[ScriptName("addKeyListener")]
		public ext.KeyMap AddKeyListener(System.Array key, System.Delegate fn)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Convenience method for constructing a KeyMap</summary>
		/// <definedin>src\core\Element.keys.js</definedin>
		/// <param name="key">
		/// Either a string with the keys to listen for, the numeric key code, array of key codes or an object with the following options:
		/// <c>{key: (number or array), shift: (true/false), ctrl: (true/false), alt: (true/false)}</c>
		/// </param>
		/// <param name="fn">The function to call</param>
		/// <returns>The KeyMap created</returns>
		[ScriptName("addKeyListener")]
		public ext.KeyMap AddKeyListener(object key, System.Delegate fn)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Convenience method for constructing a KeyMap</summary>
		/// <definedin>src\core\Element.keys.js</definedin>
		/// <param name="key">
		/// Either a string with the keys to listen for, the numeric key code, array of key codes or an object with the following options:
		/// <c>{key: (number or array), shift: (true/false), ctrl: (true/false), alt: (true/false)}</c>
		/// </param>
		/// <param name="fn">The function to call</param>
		/// <returns>The KeyMap created</returns>
		[ScriptName("addKeyListener")]
		public ext.KeyMap AddKeyListener(string key, System.Delegate fn)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Sets the element&apos;s box. Use getBox() on another element to get a box obj. If animate is true then width, height, x and y will be animated concurrently.</summary>
		/// <definedin>src\core\Element.position-more.js</definedin>
		/// <param name="box">The box to fill {x, y, width, height}</param>
		/// <param name="adjust">Whether to adjust for box-model issues automatically</param>
		/// <param name="animate">true for the default animation or a standard Element animation config object</param>
		/// <returns>this</returns>
		[ScriptName("setBox")]
		public ext.Element SetBox(object box, bool adjust, bool animate)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Sets the element&apos;s box. Use getBox() on another element to get a box obj. If animate is true then width, height, x and y will be animated concurrently.</summary>
		/// <definedin>src\core\Element.position-more.js</definedin>
		/// <param name="box">The box to fill {x, y, width, height}</param>
		/// <param name="adjust">Whether to adjust for box-model issues automatically</param>
		/// <param name="animate">true for the default animation or a standard Element animation config object</param>
		/// <returns>this</returns>
		[ScriptName("setBox")]
		public ext.Element SetBox(object box, bool adjust, object animate)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Sets the element&apos;s box. Use getBox() on another element to get a box obj. If animate is true then width, height, x and y will be animated concurrently.</summary>
		/// <definedin>src\core\Element.position-more.js</definedin>
		/// <param name="box">The box to fill {x, y, width, height}</param>
		/// <param name="adjust">Whether to adjust for box-model issues automatically</param>
		/// <returns>this</returns>
		[ScriptName("setBox")]
		public ext.Element SetBox(object box, bool adjust)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Sets the element&apos;s box. Use getBox() on another element to get a box obj. If animate is true then width, height, x and y will be animated concurrently.</summary>
		/// <definedin>src\core\Element.position-more.js</definedin>
		/// <param name="box">The box to fill {x, y, width, height}</param>
		/// <returns>this</returns>
		[ScriptName("setBox")]
		public ext.Element SetBox(object box)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Return an object defining the area of this Element which can be passed to {@link #setBox} to
		/// set another Element&apos;s size/location to match this element.
		/// </summary>
		/// <definedin>src\core\Element.position-more.js</definedin>
		/// <param name="contentBox">If true a box for the content of the element is returned.</param>
		/// <param name="local">If true the element&apos;s left and top are returned instead of page x/y.</param>
		/// <returns>
		/// box An object in the format<c>
		/// {
		/// x: &amp;lt;Element&apos;s X position&gt;,
		/// y: &amp;lt;Element&apos;s Y position&gt;,
		/// width: &amp;lt;Element&apos;s width&gt;,
		/// height: &amp;lt;Element&apos;s height&gt;,
		/// bottom: &amp;lt;Element&apos;s lower bound&gt;,
		/// right: &amp;lt;Element&apos;s rightmost bound&gt;
		/// }
		/// </c>&lt;/pre&gt;
		/// The returned object may also be addressed as an Array where index 0 contains the X position
		/// and index 1 contains the Y position. So the result may also be used for {@link #setXY}
		/// </returns>
		[ScriptName("getBox")]
		public object GetBox(bool contentBox, bool local)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Return an object defining the area of this Element which can be passed to {@link #setBox} to
		/// set another Element&apos;s size/location to match this element.
		/// </summary>
		/// <definedin>src\core\Element.position-more.js</definedin>
		/// <param name="contentBox">If true a box for the content of the element is returned.</param>
		/// <returns>
		/// box An object in the format<c>
		/// {
		/// x: &amp;lt;Element&apos;s X position&gt;,
		/// y: &amp;lt;Element&apos;s Y position&gt;,
		/// width: &amp;lt;Element&apos;s width&gt;,
		/// height: &amp;lt;Element&apos;s height&gt;,
		/// bottom: &amp;lt;Element&apos;s lower bound&gt;,
		/// right: &amp;lt;Element&apos;s rightmost bound&gt;
		/// }
		/// </c>&lt;/pre&gt;
		/// The returned object may also be addressed as an Array where index 0 contains the X position
		/// and index 1 contains the Y position. So the result may also be used for {@link #setXY}
		/// </returns>
		[ScriptName("getBox")]
		public object GetBox(bool contentBox)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Return an object defining the area of this Element which can be passed to {@link #setBox} to
		/// set another Element&apos;s size/location to match this element.
		/// </summary>
		/// <definedin>src\core\Element.position-more.js</definedin>
		/// <returns>
		/// box An object in the format<c>
		/// {
		/// x: &amp;lt;Element&apos;s X position&gt;,
		/// y: &amp;lt;Element&apos;s Y position&gt;,
		/// width: &amp;lt;Element&apos;s width&gt;,
		/// height: &amp;lt;Element&apos;s height&gt;,
		/// bottom: &amp;lt;Element&apos;s lower bound&gt;,
		/// right: &amp;lt;Element&apos;s rightmost bound&gt;
		/// }
		/// </c>&lt;/pre&gt;
		/// The returned object may also be addressed as an Array where index 0 contains the X position
		/// and index 1 contains the Y position. So the result may also be used for {@link #setXY}
		/// </returns>
		[ScriptName("getBox")]
		public object GetBox()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Move this element relative to its current position.</summary>
		/// <definedin>src\core\Element.position-more.js</definedin>
		/// <param name="direction">Possible values are: &quot;l&quot; (or &quot;left&quot;), &quot;r&quot; (or &quot;right&quot;), &quot;t&quot; (or &quot;top&quot;, or &quot;up&quot;), &quot;b&quot; (or &quot;bottom&quot;, or &quot;down&quot;).</param>
		/// <param name="distance">How far to move the element in pixels</param>
		/// <param name="animate">true for the default animation or a standard Element animation config object</param>
		/// <returns>this</returns>
		[ScriptName("move")]
		public ext.Element Move(string direction, System.Number distance, bool animate)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Move this element relative to its current position.</summary>
		/// <definedin>src\core\Element.position-more.js</definedin>
		/// <param name="direction">Possible values are: &quot;l&quot; (or &quot;left&quot;), &quot;r&quot; (or &quot;right&quot;), &quot;t&quot; (or &quot;top&quot;, or &quot;up&quot;), &quot;b&quot; (or &quot;bottom&quot;, or &quot;down&quot;).</param>
		/// <param name="distance">How far to move the element in pixels</param>
		/// <param name="animate">true for the default animation or a standard Element animation config object</param>
		/// <returns>this</returns>
		[ScriptName("move")]
		public ext.Element Move(string direction, System.Number distance, object animate)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Move this element relative to its current position.</summary>
		/// <definedin>src\core\Element.position-more.js</definedin>
		/// <param name="direction">Possible values are: &quot;l&quot; (or &quot;left&quot;), &quot;r&quot; (or &quot;right&quot;), &quot;t&quot; (or &quot;top&quot;, or &quot;up&quot;), &quot;b&quot; (or &quot;bottom&quot;, or &quot;down&quot;).</param>
		/// <param name="distance">How far to move the element in pixels</param>
		/// <returns>this</returns>
		[ScriptName("move")]
		public ext.Element Move(string direction, System.Number distance)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Sets the element&apos;s position and size in one shot. If animation is true then width, height, x and y will be animated concurrently.</summary>
		/// <definedin>src\core\Element.position-more.js</definedin>
		/// <param name="x">X value for new position (coordinates are page-based)</param>
		/// <param name="y">Y value for new position (coordinates are page-based)</param>
		/// <param name="width">
		/// The new width. This may be one of:&lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
		/// &lt;li&gt;A Number specifying the new width in this Element&apos;s {@link #defaultUnit}s (by default, pixels)&lt;/li&gt;
		/// &lt;li&gt;A String used to set the CSS width style. Animation may &lt;b&gt;not&lt;/b&gt; be used.
		/// &lt;/ul&gt;&lt;/div&gt;
		/// </param>
		/// <param name="height">
		/// The new height. This may be one of:&lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
		/// &lt;li&gt;A Number specifying the new height in this Element&apos;s {@link #defaultUnit}s (by default, pixels)&lt;/li&gt;
		/// &lt;li&gt;A String used to set the CSS height style. Animation may &lt;b&gt;not&lt;/b&gt; be used.&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		/// </param>
		/// <param name="animate">true for the default animation or a standard Element animation config object</param>
		/// <returns>this</returns>
		[ScriptName("setBounds")]
		public ext.Element SetBounds(System.Number x, System.Number y, object width, object height, bool animate)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Sets the element&apos;s position and size in one shot. If animation is true then width, height, x and y will be animated concurrently.</summary>
		/// <definedin>src\core\Element.position-more.js</definedin>
		/// <param name="x">X value for new position (coordinates are page-based)</param>
		/// <param name="y">Y value for new position (coordinates are page-based)</param>
		/// <param name="width">
		/// The new width. This may be one of:&lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
		/// &lt;li&gt;A Number specifying the new width in this Element&apos;s {@link #defaultUnit}s (by default, pixels)&lt;/li&gt;
		/// &lt;li&gt;A String used to set the CSS width style. Animation may &lt;b&gt;not&lt;/b&gt; be used.
		/// &lt;/ul&gt;&lt;/div&gt;
		/// </param>
		/// <param name="height">
		/// The new height. This may be one of:&lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
		/// &lt;li&gt;A Number specifying the new height in this Element&apos;s {@link #defaultUnit}s (by default, pixels)&lt;/li&gt;
		/// &lt;li&gt;A String used to set the CSS height style. Animation may &lt;b&gt;not&lt;/b&gt; be used.&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		/// </param>
		/// <param name="animate">true for the default animation or a standard Element animation config object</param>
		/// <returns>this</returns>
		[ScriptName("setBounds")]
		public ext.Element SetBounds(System.Number x, System.Number y, object width, object height, object animate)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Sets the element&apos;s position and size in one shot. If animation is true then width, height, x and y will be animated concurrently.</summary>
		/// <definedin>src\core\Element.position-more.js</definedin>
		/// <param name="x">X value for new position (coordinates are page-based)</param>
		/// <param name="y">Y value for new position (coordinates are page-based)</param>
		/// <param name="width">
		/// The new width. This may be one of:&lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
		/// &lt;li&gt;A Number specifying the new width in this Element&apos;s {@link #defaultUnit}s (by default, pixels)&lt;/li&gt;
		/// &lt;li&gt;A String used to set the CSS width style. Animation may &lt;b&gt;not&lt;/b&gt; be used.
		/// &lt;/ul&gt;&lt;/div&gt;
		/// </param>
		/// <param name="height">
		/// The new height. This may be one of:&lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
		/// &lt;li&gt;A Number specifying the new height in this Element&apos;s {@link #defaultUnit}s (by default, pixels)&lt;/li&gt;
		/// &lt;li&gt;A String used to set the CSS height style. Animation may &lt;b&gt;not&lt;/b&gt; be used.&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		/// </param>
		/// <returns>this</returns>
		[ScriptName("setBounds")]
		public ext.Element SetBounds(System.Number x, System.Number y, object width, object height)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Sets the element&apos;s position and size the specified region. If animation is true then width, height, x and y will be animated concurrently.</summary>
		/// <definedin>src\core\Element.position-more.js</definedin>
		/// <param name="region">The region to fill</param>
		/// <param name="animate">true for the default animation or a standard Element animation config object</param>
		/// <returns>this</returns>
		[ScriptName("setRegion")]
		public ext.Element SetRegion(ext.lib.Region region, bool animate)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Sets the element&apos;s position and size the specified region. If animation is true then width, height, x and y will be animated concurrently.</summary>
		/// <definedin>src\core\Element.position-more.js</definedin>
		/// <param name="region">The region to fill</param>
		/// <param name="animate">true for the default animation or a standard Element animation config object</param>
		/// <returns>this</returns>
		[ScriptName("setRegion")]
		public ext.Element SetRegion(ext.lib.Region region, object animate)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Sets the element&apos;s position and size the specified region. If animation is true then width, height, x and y will be animated concurrently.</summary>
		/// <definedin>src\core\Element.position-more.js</definedin>
		/// <param name="region">The region to fill</param>
		/// <returns>this</returns>
		[ScriptName("setRegion")]
		public ext.Element SetRegion(ext.lib.Region region)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Scrolls this element the specified scroll point. It does NOT do bounds checking so if you scroll to a weird value it will try to do it. For auto bounds checking, use scroll().</summary>
		/// <definedin>src\core\Element.scroll-more.js</definedin>
		/// <param name="side">Either &quot;left&quot; for scrollLeft values or &quot;top&quot; for scrollTop values.</param>
		/// <param name="value">The new scroll value</param>
		/// <param name="animate">true for the default animation or a standard Element animation config object</param>
		/// <returns>this</returns>
		[ScriptName("scrollTo")]
		public ext.Element ScrollTo(string side, System.Number value, bool animate)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Scrolls this element the specified scroll point. It does NOT do bounds checking so if you scroll to a weird value it will try to do it. For auto bounds checking, use scroll().</summary>
		/// <definedin>src\core\Element.scroll-more.js</definedin>
		/// <param name="side">Either &quot;left&quot; for scrollLeft values or &quot;top&quot; for scrollTop values.</param>
		/// <param name="value">The new scroll value</param>
		/// <param name="animate">true for the default animation or a standard Element animation config object</param>
		/// <returns>this</returns>
		[ScriptName("scrollTo")]
		public ext.Element ScrollTo(string side, System.Number value, object animate)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Scrolls this element into view within the passed container.</summary>
		/// <definedin>src\core\Element.scroll-more.js</definedin>
		/// <param name="container">
		/// The container element to scroll (defaults to document.body). Should be a
		/// string (id), dom node, or Ext.Element.
		/// </param>
		/// <param name="hscroll">False to disable horizontal scroll (defaults to true)</param>
		/// <returns>this</returns>
		[ScriptName("scrollIntoView")]
		public ext.Element ScrollIntoView(object container, bool hscroll)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Scrolls this element into view within the passed container.</summary>
		/// <definedin>src\core\Element.scroll-more.js</definedin>
		/// <param name="container">
		/// The container element to scroll (defaults to document.body). Should be a
		/// string (id), dom node, or Ext.Element.
		/// </param>
		/// <returns>this</returns>
		[ScriptName("scrollIntoView")]
		public ext.Element ScrollIntoView(object container)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Scrolls this element into view within the passed container.</summary>
		/// <definedin>src\core\Element.scroll-more.js</definedin>
		/// <returns>this</returns>
		[ScriptName("scrollIntoView")]
		public ext.Element ScrollIntoView()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Scrolls this element the specified direction. Does bounds checking to make sure the scroll is
		/// within this element&apos;s scrollable range.
		/// </summary>
		/// <definedin>src\core\Element.scroll-more.js</definedin>
		/// <param name="direction">Possible values are: &quot;l&quot; (or &quot;left&quot;), &quot;r&quot; (or &quot;right&quot;), &quot;t&quot; (or &quot;top&quot;, or &quot;up&quot;), &quot;b&quot; (or &quot;bottom&quot;, or &quot;down&quot;).</param>
		/// <param name="distance">How far to scroll the element in pixels</param>
		/// <param name="animate">true for the default animation or a standard Element animation config object</param>
		/// <returns>
		/// Returns true if a scroll was triggered or false if the element
		/// was scrolled as far as it could go.
		/// </returns>
		[ScriptName("scroll")]
		public bool ScrollMethod(string direction, System.Number distance, bool animate)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Scrolls this element the specified direction. Does bounds checking to make sure the scroll is
		/// within this element&apos;s scrollable range.
		/// </summary>
		/// <definedin>src\core\Element.scroll-more.js</definedin>
		/// <param name="direction">Possible values are: &quot;l&quot; (or &quot;left&quot;), &quot;r&quot; (or &quot;right&quot;), &quot;t&quot; (or &quot;top&quot;, or &quot;up&quot;), &quot;b&quot; (or &quot;bottom&quot;, or &quot;down&quot;).</param>
		/// <param name="distance">How far to scroll the element in pixels</param>
		/// <param name="animate">true for the default animation or a standard Element animation config object</param>
		/// <returns>
		/// Returns true if a scroll was triggered or false if the element
		/// was scrolled as far as it could go.
		/// </returns>
		[ScriptName("scroll")]
		public bool ScrollMethod(string direction, System.Number distance, object animate)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Scrolls this element the specified direction. Does bounds checking to make sure the scroll is
		/// within this element&apos;s scrollable range.
		/// </summary>
		/// <definedin>src\core\Element.scroll-more.js</definedin>
		/// <param name="direction">Possible values are: &quot;l&quot; (or &quot;left&quot;), &quot;r&quot; (or &quot;right&quot;), &quot;t&quot; (or &quot;top&quot;, or &quot;up&quot;), &quot;b&quot; (or &quot;bottom&quot;, or &quot;down&quot;).</param>
		/// <param name="distance">How far to scroll the element in pixels</param>
		/// <returns>
		/// Returns true if a scroll was triggered or false if the element
		/// was scrolled as far as it could go.
		/// </returns>
		[ScriptName("scroll")]
		public bool ScrollMethod(string direction, System.Number distance)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>More flexible version of {@link #setStyle} for setting style properties.</summary>
		/// <definedin>src\core\Element.style-more.js</definedin>
		/// <param name="styles">
		/// A style specification string, e.g. &quot;width:100px&quot;, or object in the form {width:&quot;100px&quot;}, or
		/// a function which returns such a specification.
		/// </param>
		/// <returns>this</returns>
		[ScriptName("applyStyles")]
		public ext.Element ApplyStyles(string styles)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>More flexible version of {@link #setStyle} for setting style properties.</summary>
		/// <definedin>src\core\Element.style-more.js</definedin>
		/// <param name="styles">
		/// A style specification string, e.g. &quot;width:100px&quot;, or object in the form {width:&quot;100px&quot;}, or
		/// a function which returns such a specification.
		/// </param>
		/// <returns>this</returns>
		[ScriptName("applyStyles")]
		public ext.Element ApplyStyles(object styles)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>More flexible version of {@link #setStyle} for setting style properties.</summary>
		/// <definedin>src\core\Element.style-more.js</definedin>
		/// <param name="styles">
		/// A style specification string, e.g. &quot;width:100px&quot;, or object in the form {width:&quot;100px&quot;}, or
		/// a function which returns such a specification.
		/// </param>
		/// <returns>this</returns>
		[ScriptName("applyStyles")]
		public ext.Element ApplyStyles(System.Delegate styles)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Returns an object with properties matching the styles requested.
		/// For example, el.getStyles(&apos;color&apos;, &apos;font-size&apos;, &apos;width&apos;) might return
		/// {&apos;color&apos;: &apos;#FFFFFF&apos;, &apos;font-size&apos;: &apos;13px&apos;, &apos;width&apos;: &apos;100px&apos;}.
		/// </summary>
		/// <definedin>src\core\Element.style-more.js</definedin>
		/// <param name="styles">A style name</param>
		/// <returns>The style object</returns>
		[ScriptName("getStyles")]
		public object GetStyles(params string[] styles)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Returns an object with properties matching the styles requested.
		/// For example, el.getStyles(&apos;color&apos;, &apos;font-size&apos;, &apos;width&apos;) might return
		/// {&apos;color&apos;: &apos;#FFFFFF&apos;, &apos;font-size&apos;: &apos;13px&apos;, &apos;width&apos;: &apos;100px&apos;}.
		/// </summary>
		/// <definedin>src\core\Element.style-more.js</definedin>
		/// <returns>The style object</returns>
		[ScriptName("getStyles")]
		public object GetStyles()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Wraps the specified element with a special 9 element markup/CSS block that renders by default as
		/// a gray container with a gradient background, rounded corners and a 4-way shadow.  This special markup is used throughout Ext when box wrapping elements ({@link Ext.Button},
		/// {@link Ext.Panel} when {@link Ext.Panel#frame frame=true}, {@link Ext.Window}). The markup
		/// is of this form:  
		/// Ext.Element.boxMarkup =
		/// &apos;&amp;lt;div class=&quot;{0}-tl&quot;&gt;&amp;lt;div class=&quot;{0}-tr&quot;&gt;&amp;lt;div class=&quot;{0}-tc&quot;&gt;&amp;lt;/div&gt;&amp;lt;/div&gt;&amp;lt;/div&gt;
		/// &amp;lt;div class=&quot;{0}-ml&quot;&gt;&amp;lt;div class=&quot;{0}-mr&quot;&gt;&amp;lt;div class=&quot;{0}-mc&quot;&gt;&amp;lt;/div&gt;&amp;lt;/div&gt;&amp;lt;/div&gt;
		/// &amp;lt;div class=&quot;{0}-bl&quot;&gt;&amp;lt;div class=&quot;{0}-br&quot;&gt;&amp;lt;div class=&quot;{0}-bc&quot;&gt;&amp;lt;/div&gt;&amp;lt;/div&gt;&amp;lt;/div&gt;&apos;;
		///  Example usage:  
		/// // Basic box wrap
		/// Ext.get(&quot;foo&quot;).boxWrap();
		///
		/// // You can also add a custom class and use CSS inheritance rules to customize the box look.
		/// // &apos;x-box-blue&apos; is a built-in alternative -- look at the related CSS definitions as an example
		/// // for how to create a custom...
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Wraps the specified element with a special 9 element markup/CSS block that renders by default as
		/// a gray container with a gradient background, rounded corners and a 4-way shadow.&lt;/p&gt;
		/// &lt;p&gt;This special markup is used throughout Ext when box wrapping elements ({@link Ext.Button},
		/// {@link Ext.Panel} when &lt;tt&gt;{@link Ext.Panel#frame frame=true}&lt;/tt&gt;, {@link Ext.Window}). The markup
		/// is of this form:&lt;/p&gt;
		/// &lt;pre&gt;&lt;code&gt;
		/// Ext.Element.boxMarkup =
		/// &amp;#39;&amp;lt;div class=&quot;{0}-tl&quot;&gt;&amp;lt;div class=&quot;{0}-tr&quot;&gt;&amp;lt;div class=&quot;{0}-tc&quot;&gt;&amp;lt;/div&gt;&amp;lt;/div&gt;&amp;lt;/div&gt;
		/// &amp;lt;div class=&quot;{0}-ml&quot;&gt;&amp;lt;div class=&quot;{0}-mr&quot;&gt;&amp;lt;div class=&quot;{0}-mc&quot;&gt;&amp;lt;/div&gt;&amp;lt;/div&gt;&amp;lt;/div&gt;
		/// &amp;lt;div class=&quot;{0}-bl&quot;&gt;&amp;lt;div class=&quot;{0}-br&quot;&gt;&amp;lt;div class=&quot;{0}-bc&quot;&gt;&amp;lt;/div&gt;&amp;lt;/div&gt;&amp;lt;/div&gt;&amp;#39;;
		/// &lt;/code&gt;&lt;/pre&gt;
		/// &lt;p&gt;Example usage:&lt;/p&gt;
		/// &lt;pre&gt;&lt;code&gt;
		/// // Basic box wrap
		/// Ext.get(&quot;foo&quot;).boxWrap();
		///
		/// // You can also add a custom class and use CSS inheritance rules to customize the box look.
		/// // &apos;x-box-blue&apos; is a built-in alternative -- look at the related CSS definitions as an example
		/// // for how to create a custom box wrap style.
		/// Ext.get(&quot;foo&quot;).boxWrap().addClass(&quot;x-box-blue&quot;);
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\core\Element.style-more.js</definedin>
		/// <param name="class">
		/// A base CSS class to apply to the containing wrapper element
		/// (defaults to &lt;tt&gt;&apos;x-box&apos;&lt;/tt&gt;). Note that there are a number of CSS rules that are dependent on
		/// this name to make the overall effect work, so if you supply an alternate base class, make sure you
		/// also supply all of the necessary rules.
		/// </param>
		/// <returns>The outermost wrapping element of the created box structure.</returns>
		[ScriptName("boxWrap")]
		public ext.Element BoxWrap(string @class)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Wraps the specified element with a special 9 element markup/CSS block that renders by default as
		/// a gray container with a gradient background, rounded corners and a 4-way shadow.  This special markup is used throughout Ext when box wrapping elements ({@link Ext.Button},
		/// {@link Ext.Panel} when {@link Ext.Panel#frame frame=true}, {@link Ext.Window}). The markup
		/// is of this form:  
		/// Ext.Element.boxMarkup =
		/// &apos;&amp;lt;div class=&quot;{0}-tl&quot;&gt;&amp;lt;div class=&quot;{0}-tr&quot;&gt;&amp;lt;div class=&quot;{0}-tc&quot;&gt;&amp;lt;/div&gt;&amp;lt;/div&gt;&amp;lt;/div&gt;
		/// &amp;lt;div class=&quot;{0}-ml&quot;&gt;&amp;lt;div class=&quot;{0}-mr&quot;&gt;&amp;lt;div class=&quot;{0}-mc&quot;&gt;&amp;lt;/div&gt;&amp;lt;/div&gt;&amp;lt;/div&gt;
		/// &amp;lt;div class=&quot;{0}-bl&quot;&gt;&amp;lt;div class=&quot;{0}-br&quot;&gt;&amp;lt;div class=&quot;{0}-bc&quot;&gt;&amp;lt;/div&gt;&amp;lt;/div&gt;&amp;lt;/div&gt;&apos;;
		///  Example usage:  
		/// // Basic box wrap
		/// Ext.get(&quot;foo&quot;).boxWrap();
		///
		/// // You can also add a custom class and use CSS inheritance rules to customize the box look.
		/// // &apos;x-box-blue&apos; is a built-in alternative -- look at the related CSS definitions as an example
		/// // for how to create a custom...
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Wraps the specified element with a special 9 element markup/CSS block that renders by default as
		/// a gray container with a gradient background, rounded corners and a 4-way shadow.&lt;/p&gt;
		/// &lt;p&gt;This special markup is used throughout Ext when box wrapping elements ({@link Ext.Button},
		/// {@link Ext.Panel} when &lt;tt&gt;{@link Ext.Panel#frame frame=true}&lt;/tt&gt;, {@link Ext.Window}). The markup
		/// is of this form:&lt;/p&gt;
		/// &lt;pre&gt;&lt;code&gt;
		/// Ext.Element.boxMarkup =
		/// &amp;#39;&amp;lt;div class=&quot;{0}-tl&quot;&gt;&amp;lt;div class=&quot;{0}-tr&quot;&gt;&amp;lt;div class=&quot;{0}-tc&quot;&gt;&amp;lt;/div&gt;&amp;lt;/div&gt;&amp;lt;/div&gt;
		/// &amp;lt;div class=&quot;{0}-ml&quot;&gt;&amp;lt;div class=&quot;{0}-mr&quot;&gt;&amp;lt;div class=&quot;{0}-mc&quot;&gt;&amp;lt;/div&gt;&amp;lt;/div&gt;&amp;lt;/div&gt;
		/// &amp;lt;div class=&quot;{0}-bl&quot;&gt;&amp;lt;div class=&quot;{0}-br&quot;&gt;&amp;lt;div class=&quot;{0}-bc&quot;&gt;&amp;lt;/div&gt;&amp;lt;/div&gt;&amp;lt;/div&gt;&amp;#39;;
		/// &lt;/code&gt;&lt;/pre&gt;
		/// &lt;p&gt;Example usage:&lt;/p&gt;
		/// &lt;pre&gt;&lt;code&gt;
		/// // Basic box wrap
		/// Ext.get(&quot;foo&quot;).boxWrap();
		///
		/// // You can also add a custom class and use CSS inheritance rules to customize the box look.
		/// // &apos;x-box-blue&apos; is a built-in alternative -- look at the related CSS definitions as an example
		/// // for how to create a custom box wrap style.
		/// Ext.get(&quot;foo&quot;).boxWrap().addClass(&quot;x-box-blue&quot;);
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\core\Element.style-more.js</definedin>
		/// <returns>The outermost wrapping element of the created box structure.</returns>
		[ScriptName("boxWrap")]
		public ext.Element BoxWrap()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Set the size of this Element. If animation is true, both width and height will be animated concurrently.</summary>
		/// <definedin>src\core\Element.style-more.js</definedin>
		/// <param name="width">
		/// The new width. This may be one of:&lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
		/// &lt;li&gt;A Number specifying the new width in this Element&apos;s {@link #defaultUnit}s (by default, pixels).&lt;/li&gt;
		/// &lt;li&gt;A String used to set the CSS width style. Animation may &lt;b&gt;not&lt;/b&gt; be used.
		/// &lt;li&gt;A size object in the format <c>{width: widthValue, height: heightValue}</c>.&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		/// </param>
		/// <param name="height">
		/// The new height. This may be one of:&lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
		/// &lt;li&gt;A Number specifying the new height in this Element&apos;s {@link #defaultUnit}s (by default, pixels).&lt;/li&gt;
		/// &lt;li&gt;A String used to set the CSS height style. Animation may &lt;b&gt;not&lt;/b&gt; be used.&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		/// </param>
		/// <param name="animate">true for the default animation or a standard Element animation config object</param>
		/// <returns>this</returns>
		[ScriptName("setSize")]
		public ext.Element SetSize(object width, object height, bool animate)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Set the size of this Element. If animation is true, both width and height will be animated concurrently.</summary>
		/// <definedin>src\core\Element.style-more.js</definedin>
		/// <param name="width">
		/// The new width. This may be one of:&lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
		/// &lt;li&gt;A Number specifying the new width in this Element&apos;s {@link #defaultUnit}s (by default, pixels).&lt;/li&gt;
		/// &lt;li&gt;A String used to set the CSS width style. Animation may &lt;b&gt;not&lt;/b&gt; be used.
		/// &lt;li&gt;A size object in the format <c>{width: widthValue, height: heightValue}</c>.&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		/// </param>
		/// <param name="height">
		/// The new height. This may be one of:&lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
		/// &lt;li&gt;A Number specifying the new height in this Element&apos;s {@link #defaultUnit}s (by default, pixels).&lt;/li&gt;
		/// &lt;li&gt;A String used to set the CSS height style. Animation may &lt;b&gt;not&lt;/b&gt; be used.&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		/// </param>
		/// <param name="animate">true for the default animation or a standard Element animation config object</param>
		/// <returns>this</returns>
		[ScriptName("setSize")]
		public ext.Element SetSize(object width, object height, object animate)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Set the size of this Element. If animation is true, both width and height will be animated concurrently.</summary>
		/// <definedin>src\core\Element.style-more.js</definedin>
		/// <param name="width">
		/// The new width. This may be one of:&lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
		/// &lt;li&gt;A Number specifying the new width in this Element&apos;s {@link #defaultUnit}s (by default, pixels).&lt;/li&gt;
		/// &lt;li&gt;A String used to set the CSS width style. Animation may &lt;b&gt;not&lt;/b&gt; be used.
		/// &lt;li&gt;A size object in the format <c>{width: widthValue, height: heightValue}</c>.&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		/// </param>
		/// <param name="height">
		/// The new height. This may be one of:&lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
		/// &lt;li&gt;A Number specifying the new height in this Element&apos;s {@link #defaultUnit}s (by default, pixels).&lt;/li&gt;
		/// &lt;li&gt;A String used to set the CSS height style. Animation may &lt;b&gt;not&lt;/b&gt; be used.&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		/// </param>
		/// <returns>this</returns>
		[ScriptName("setSize")]
		public ext.Element SetSize(object width, object height)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns the size of the element.</summary>
		/// <definedin>src\core\Element.style-more.js</definedin>
		/// <param name="contentSize">true to get the width/size minus borders and padding</param>
		/// <returns>An object containing the element&apos;s size {width: (element width), height: (element height)}</returns>
		[ScriptName("getSize")]
		public object GetSize(bool contentSize)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns the size of the element.</summary>
		/// <definedin>src\core\Element.style-more.js</definedin>
		/// <returns>An object containing the element&apos;s size {width: (element width), height: (element height)}</returns>
		[ScriptName("getSize")]
		public object GetSize()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Returns an object with properties top, left, right and bottom representing the margins of this element unless sides is passed,
		/// then it returns the calculated width of the sides (see getPadding)
		/// </summary>
		/// <definedin>src\core\Element.style-more.js</definedin>
		/// <param name="sides">Any combination of l, r, t, b to get the sum of those sides</param>
		[ScriptName("getMargins")]
		public ext.auto.System_Object_Or_System_Number GetMargins(string sides)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Returns an object with properties top, left, right and bottom representing the margins of this element unless sides is passed,
		/// then it returns the calculated width of the sides (see getPadding)
		/// </summary>
		/// <definedin>src\core\Element.style-more.js</definedin>
		[ScriptName("getMargins")]
		public ext.auto.System_Object_Or_System_Number GetMargins()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Selects elements based on the passed CSS selector to enable {@link Ext.Element Element} methods
		/// to be applied to many related elements in one statement through the returned {@link Ext.CompositeElement CompositeElement} or
		/// {@link Ext.CompositeElementLite CompositeElementLite} object.
		/// </summary>
		/// <definedin>src\ext-core\src\core\CompositeElementLite.js</definedin>
		/// <param name="selector">The CSS selector or an array of elements</param>
		/// <param name="root">The root element of the query or id of the root</param>
		[ScriptName("select")]
		public static ext.auto.ext_CompositeElementLite_Or_ext_CompositeElement SelectMethod(string selector, System.Html.Element root)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Selects elements based on the passed CSS selector to enable {@link Ext.Element Element} methods
		/// to be applied to many related elements in one statement through the returned {@link Ext.CompositeElement CompositeElement} or
		/// {@link Ext.CompositeElementLite CompositeElementLite} object.
		/// </summary>
		/// <definedin>src\ext-core\src\core\CompositeElementLite.js</definedin>
		/// <param name="selector">The CSS selector or an array of elements</param>
		/// <param name="root">The root element of the query or id of the root</param>
		[ScriptName("select")]
		public static ext.auto.ext_CompositeElementLite_Or_ext_CompositeElement SelectMethod(string selector, string root)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Selects elements based on the passed CSS selector to enable {@link Ext.Element Element} methods
		/// to be applied to many related elements in one statement through the returned {@link Ext.CompositeElement CompositeElement} or
		/// {@link Ext.CompositeElementLite CompositeElementLite} object.
		/// </summary>
		/// <definedin>src\ext-core\src\core\CompositeElementLite.js</definedin>
		/// <param name="selector">The CSS selector or an array of elements</param>
		/// <param name="root">The root element of the query or id of the root</param>
		[ScriptName("select")]
		public static ext.auto.ext_CompositeElementLite_Or_ext_CompositeElement SelectMethod(System.Array selector, System.Html.Element root)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Selects elements based on the passed CSS selector to enable {@link Ext.Element Element} methods
		/// to be applied to many related elements in one statement through the returned {@link Ext.CompositeElement CompositeElement} or
		/// {@link Ext.CompositeElementLite CompositeElementLite} object.
		/// </summary>
		/// <definedin>src\ext-core\src\core\CompositeElementLite.js</definedin>
		/// <param name="selector">The CSS selector or an array of elements</param>
		/// <param name="root">The root element of the query or id of the root</param>
		[ScriptName("select")]
		public static ext.auto.ext_CompositeElementLite_Or_ext_CompositeElement SelectMethod(System.Array selector, string root)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Perform custom animation on this element.
		///   Animation Properties  The Animation Control Object enables gradual transitions for any member of an
		/// element&apos;s style object that takes a numeric value including but not limited to
		/// these properties:    bottom, top, left, right  height, width  margin, padding  borderWidth  opacity  fontSize  lineHeight    Animation Property Attributes  Each Animation Property is a config object with optional properties:    by* : relative change - start at current value, change by this value  from : ignore current value, start from this value  to* : start at current value, go to this value  unit : any allowable unit specification  * do not specify both to and by for an animation property    Animation Types  The supported animation types:    &apos;run&apos; : Default
		/// 
		/// var el = Ext.get(&apos;complexEl&apos;);
		/// el.animate(
		/// // animation control object
		/// {
		/// borderWidth: {to: 3, from: 0},
		/// opacity: {to: .3, from: 1},
		/// height: {to: 50, from: el.getHeight()},
		/// width: {to: 300,...
		/// </summary>
		/// <htmlSummary>
		/// Perform custom animation on this element.
		/// &lt;div&gt;&lt;ul class=&quot;mdetail-params&quot;&gt;
		/// &lt;li&gt;&lt;u&gt;Animation Properties&lt;/u&gt;&lt;/li&gt;
		///
		/// &lt;p&gt;The Animation Control Object enables gradual transitions for any member of an
		/// element&apos;s style object that takes a numeric value including but not limited to
		/// these properties:&lt;/p&gt;&lt;div&gt;&lt;ul class=&quot;mdetail-params&quot;&gt;
		/// &lt;li&gt;&lt;tt&gt;bottom, top, left, right&lt;/tt&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;height, width&lt;/tt&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;margin, padding&lt;/tt&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;borderWidth&lt;/tt&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;opacity&lt;/tt&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;fontSize&lt;/tt&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;lineHeight&lt;/tt&gt;&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		///
		///
		/// &lt;li&gt;&lt;u&gt;Animation Property Attributes&lt;/u&gt;&lt;/li&gt;
		///
		/// &lt;p&gt;Each Animation Property is a config object with optional properties:&lt;/p&gt;
		/// &lt;div&gt;&lt;ul class=&quot;mdetail-params&quot;&gt;
		/// &lt;li&gt;&lt;tt&gt;by&lt;/tt&gt;* : relative change - start at current value, change by this value&lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;from&lt;/tt&gt; : ignore current value, start from this value&lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;to&lt;/tt&gt;* : start at current value, go to this value&lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;unit&lt;/tt&gt; : any allowable unit specification&lt;/li&gt;
		/// &lt;p&gt;* do not specify both &lt;tt&gt;to&lt;/tt&gt; and &lt;tt&gt;by&lt;/tt&gt; for an animation property&lt;/p&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		///
		/// &lt;li&gt;&lt;u&gt;Animation Types&lt;/u&gt;&lt;/li&gt;
		///
		/// &lt;p&gt;The supported animation types:&lt;/p&gt;&lt;div&gt;&lt;ul class=&quot;mdetail-params&quot;&gt;
		/// &lt;li&gt;&lt;tt&gt;&apos;run&apos;&lt;/tt&gt; : Default
		/// &lt;pre&gt;&lt;code&gt;
		/// var el = Ext.get(&apos;complexEl&apos;);
		/// el.animate(
		/// // animation control object
		/// {
		/// borderWidth: {to: 3, from: 0},
		/// opacity: {to: .3, from: 1},
		/// height: {to: 50, from: el.getHeight()},
		/// width: {to: 300, from: el.getWidth()},
		/// top : {by: - 100, unit: &apos;px&apos;},
		/// },
		/// 0.35, // animation duration
		/// null, // callback
		/// &apos;easeOut&apos;, // easing method
		/// &apos;run&apos; // animation type (&apos;run&apos;,&apos;color&apos;,&apos;motion&apos;,&apos;scroll&apos;)
		/// );
		/// &lt;/code&gt;&lt;/pre&gt;
		/// &lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;&apos;color&apos;&lt;/tt&gt;
		/// &lt;p&gt;Animates transition of background, text, or border colors.&lt;/p&gt;
		/// &lt;pre&gt;&lt;code&gt;
		/// el.animate(
		/// // animation control object
		/// {
		/// color: { to: &apos;#06e&apos; },
		/// backgroundColor: { to: &apos;#e06&apos; }
		/// },
		/// 0.35, // animation duration
		/// null, // callback
		/// &apos;easeOut&apos;, // easing method
		/// &apos;color&apos; // animation type (&apos;run&apos;,&apos;color&apos;,&apos;motion&apos;,&apos;scroll&apos;)
		/// );
		/// &lt;/code&gt;&lt;/pre&gt;
		/// &lt;/li&gt;
		///
		/// &lt;li&gt;&lt;tt&gt;&apos;motion&apos;&lt;/tt&gt;
		/// &lt;p&gt;Animates the motion of an element to/from specific points using optional bezier
		/// way points during transit.&lt;/p&gt;
		/// &lt;pre&gt;&lt;code&gt;
		/// el.animate(
		/// // animation control object
		/// {
		/// borderWidth: {to: 3, from: 0},
		/// opacity: {to: .3, from: 1},
		/// height: {to: 50, from: el.getHeight()},
		/// width: {to: 300, from: el.getWidth()},
		/// top : {by: - 100, unit: &apos;px&apos;},
		/// points: {
		/// to: [50, 100], // go to this point
		/// control: [ // optional bezier way points
		/// [ 600, 800],
		/// [-100, 200]
		/// ]
		/// }
		/// },
		/// 3000, // animation duration (milliseconds!)
		/// null, // callback
		/// &apos;easeOut&apos;, // easing method
		/// &apos;motion&apos; // animation type (&apos;run&apos;,&apos;color&apos;,&apos;motion&apos;,&apos;scroll&apos;)
		/// );
		/// &lt;/code&gt;&lt;/pre&gt;
		/// &lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;&apos;scroll&apos;&lt;/tt&gt;
		/// &lt;p&gt;Animate horizontal or vertical scrolling of an overflowing page element.&lt;/p&gt;
		/// &lt;pre&gt;&lt;code&gt;
		/// el.animate(
		/// // animation control object
		/// {
		/// scroll: {to: [400, 300]}
		/// },
		/// 0.35, // animation duration
		/// null, // callback
		/// &apos;easeOut&apos;, // easing method
		/// &apos;scroll&apos; // animation type (&apos;run&apos;,&apos;color&apos;,&apos;motion&apos;,&apos;scroll&apos;)
		/// );
		/// &lt;/code&gt;&lt;/pre&gt;
		/// &lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		///
		/// &lt;/ul&gt;&lt;/div&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Element.fx.js</definedin>
		/// <param name="args">The animation control args</param>
		/// <param name="duration">How long the animation lasts in seconds (defaults to &lt;tt&gt;.35&lt;/tt&gt;)</param>
		/// <param name="onComplete">Function to call when animation completes</param>
		/// <param name="easing">{@link Ext.Fx#easing} method to use (defaults to &lt;tt&gt;&apos;easeOut&apos;&lt;/tt&gt;)</param>
		/// <param name="animType">
		/// &lt;tt&gt;&apos;run&apos;&lt;/tt&gt; is the default. Can also be &lt;tt&gt;&apos;color&apos;&lt;/tt&gt;,
		/// &lt;tt&gt;&apos;motion&apos;&lt;/tt&gt;, or &lt;tt&gt;&apos;scroll&apos;&lt;/tt&gt;
		/// </param>
		/// <returns>this</returns>
		[ScriptName("animate")]
		public ext.Element Animate(object args, float duration, System.Delegate onComplete, string easing, string animType)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Perform custom animation on this element.
		///   Animation Properties  The Animation Control Object enables gradual transitions for any member of an
		/// element&apos;s style object that takes a numeric value including but not limited to
		/// these properties:    bottom, top, left, right  height, width  margin, padding  borderWidth  opacity  fontSize  lineHeight    Animation Property Attributes  Each Animation Property is a config object with optional properties:    by* : relative change - start at current value, change by this value  from : ignore current value, start from this value  to* : start at current value, go to this value  unit : any allowable unit specification  * do not specify both to and by for an animation property    Animation Types  The supported animation types:    &apos;run&apos; : Default
		/// 
		/// var el = Ext.get(&apos;complexEl&apos;);
		/// el.animate(
		/// // animation control object
		/// {
		/// borderWidth: {to: 3, from: 0},
		/// opacity: {to: .3, from: 1},
		/// height: {to: 50, from: el.getHeight()},
		/// width: {to: 300,...
		/// </summary>
		/// <htmlSummary>
		/// Perform custom animation on this element.
		/// &lt;div&gt;&lt;ul class=&quot;mdetail-params&quot;&gt;
		/// &lt;li&gt;&lt;u&gt;Animation Properties&lt;/u&gt;&lt;/li&gt;
		///
		/// &lt;p&gt;The Animation Control Object enables gradual transitions for any member of an
		/// element&apos;s style object that takes a numeric value including but not limited to
		/// these properties:&lt;/p&gt;&lt;div&gt;&lt;ul class=&quot;mdetail-params&quot;&gt;
		/// &lt;li&gt;&lt;tt&gt;bottom, top, left, right&lt;/tt&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;height, width&lt;/tt&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;margin, padding&lt;/tt&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;borderWidth&lt;/tt&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;opacity&lt;/tt&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;fontSize&lt;/tt&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;lineHeight&lt;/tt&gt;&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		///
		///
		/// &lt;li&gt;&lt;u&gt;Animation Property Attributes&lt;/u&gt;&lt;/li&gt;
		///
		/// &lt;p&gt;Each Animation Property is a config object with optional properties:&lt;/p&gt;
		/// &lt;div&gt;&lt;ul class=&quot;mdetail-params&quot;&gt;
		/// &lt;li&gt;&lt;tt&gt;by&lt;/tt&gt;* : relative change - start at current value, change by this value&lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;from&lt;/tt&gt; : ignore current value, start from this value&lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;to&lt;/tt&gt;* : start at current value, go to this value&lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;unit&lt;/tt&gt; : any allowable unit specification&lt;/li&gt;
		/// &lt;p&gt;* do not specify both &lt;tt&gt;to&lt;/tt&gt; and &lt;tt&gt;by&lt;/tt&gt; for an animation property&lt;/p&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		///
		/// &lt;li&gt;&lt;u&gt;Animation Types&lt;/u&gt;&lt;/li&gt;
		///
		/// &lt;p&gt;The supported animation types:&lt;/p&gt;&lt;div&gt;&lt;ul class=&quot;mdetail-params&quot;&gt;
		/// &lt;li&gt;&lt;tt&gt;&apos;run&apos;&lt;/tt&gt; : Default
		/// &lt;pre&gt;&lt;code&gt;
		/// var el = Ext.get(&apos;complexEl&apos;);
		/// el.animate(
		/// // animation control object
		/// {
		/// borderWidth: {to: 3, from: 0},
		/// opacity: {to: .3, from: 1},
		/// height: {to: 50, from: el.getHeight()},
		/// width: {to: 300, from: el.getWidth()},
		/// top : {by: - 100, unit: &apos;px&apos;},
		/// },
		/// 0.35, // animation duration
		/// null, // callback
		/// &apos;easeOut&apos;, // easing method
		/// &apos;run&apos; // animation type (&apos;run&apos;,&apos;color&apos;,&apos;motion&apos;,&apos;scroll&apos;)
		/// );
		/// &lt;/code&gt;&lt;/pre&gt;
		/// &lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;&apos;color&apos;&lt;/tt&gt;
		/// &lt;p&gt;Animates transition of background, text, or border colors.&lt;/p&gt;
		/// &lt;pre&gt;&lt;code&gt;
		/// el.animate(
		/// // animation control object
		/// {
		/// color: { to: &apos;#06e&apos; },
		/// backgroundColor: { to: &apos;#e06&apos; }
		/// },
		/// 0.35, // animation duration
		/// null, // callback
		/// &apos;easeOut&apos;, // easing method
		/// &apos;color&apos; // animation type (&apos;run&apos;,&apos;color&apos;,&apos;motion&apos;,&apos;scroll&apos;)
		/// );
		/// &lt;/code&gt;&lt;/pre&gt;
		/// &lt;/li&gt;
		///
		/// &lt;li&gt;&lt;tt&gt;&apos;motion&apos;&lt;/tt&gt;
		/// &lt;p&gt;Animates the motion of an element to/from specific points using optional bezier
		/// way points during transit.&lt;/p&gt;
		/// &lt;pre&gt;&lt;code&gt;
		/// el.animate(
		/// // animation control object
		/// {
		/// borderWidth: {to: 3, from: 0},
		/// opacity: {to: .3, from: 1},
		/// height: {to: 50, from: el.getHeight()},
		/// width: {to: 300, from: el.getWidth()},
		/// top : {by: - 100, unit: &apos;px&apos;},
		/// points: {
		/// to: [50, 100], // go to this point
		/// control: [ // optional bezier way points
		/// [ 600, 800],
		/// [-100, 200]
		/// ]
		/// }
		/// },
		/// 3000, // animation duration (milliseconds!)
		/// null, // callback
		/// &apos;easeOut&apos;, // easing method
		/// &apos;motion&apos; // animation type (&apos;run&apos;,&apos;color&apos;,&apos;motion&apos;,&apos;scroll&apos;)
		/// );
		/// &lt;/code&gt;&lt;/pre&gt;
		/// &lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;&apos;scroll&apos;&lt;/tt&gt;
		/// &lt;p&gt;Animate horizontal or vertical scrolling of an overflowing page element.&lt;/p&gt;
		/// &lt;pre&gt;&lt;code&gt;
		/// el.animate(
		/// // animation control object
		/// {
		/// scroll: {to: [400, 300]}
		/// },
		/// 0.35, // animation duration
		/// null, // callback
		/// &apos;easeOut&apos;, // easing method
		/// &apos;scroll&apos; // animation type (&apos;run&apos;,&apos;color&apos;,&apos;motion&apos;,&apos;scroll&apos;)
		/// );
		/// &lt;/code&gt;&lt;/pre&gt;
		/// &lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		///
		/// &lt;/ul&gt;&lt;/div&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Element.fx.js</definedin>
		/// <param name="args">The animation control args</param>
		/// <param name="duration">How long the animation lasts in seconds (defaults to &lt;tt&gt;.35&lt;/tt&gt;)</param>
		/// <param name="onComplete">Function to call when animation completes</param>
		/// <param name="easing">{@link Ext.Fx#easing} method to use (defaults to &lt;tt&gt;&apos;easeOut&apos;&lt;/tt&gt;)</param>
		/// <returns>this</returns>
		[ScriptName("animate")]
		public ext.Element Animate(object args, float duration, System.Delegate onComplete, string easing)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Perform custom animation on this element.
		///   Animation Properties  The Animation Control Object enables gradual transitions for any member of an
		/// element&apos;s style object that takes a numeric value including but not limited to
		/// these properties:    bottom, top, left, right  height, width  margin, padding  borderWidth  opacity  fontSize  lineHeight    Animation Property Attributes  Each Animation Property is a config object with optional properties:    by* : relative change - start at current value, change by this value  from : ignore current value, start from this value  to* : start at current value, go to this value  unit : any allowable unit specification  * do not specify both to and by for an animation property    Animation Types  The supported animation types:    &apos;run&apos; : Default
		/// 
		/// var el = Ext.get(&apos;complexEl&apos;);
		/// el.animate(
		/// // animation control object
		/// {
		/// borderWidth: {to: 3, from: 0},
		/// opacity: {to: .3, from: 1},
		/// height: {to: 50, from: el.getHeight()},
		/// width: {to: 300,...
		/// </summary>
		/// <htmlSummary>
		/// Perform custom animation on this element.
		/// &lt;div&gt;&lt;ul class=&quot;mdetail-params&quot;&gt;
		/// &lt;li&gt;&lt;u&gt;Animation Properties&lt;/u&gt;&lt;/li&gt;
		///
		/// &lt;p&gt;The Animation Control Object enables gradual transitions for any member of an
		/// element&apos;s style object that takes a numeric value including but not limited to
		/// these properties:&lt;/p&gt;&lt;div&gt;&lt;ul class=&quot;mdetail-params&quot;&gt;
		/// &lt;li&gt;&lt;tt&gt;bottom, top, left, right&lt;/tt&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;height, width&lt;/tt&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;margin, padding&lt;/tt&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;borderWidth&lt;/tt&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;opacity&lt;/tt&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;fontSize&lt;/tt&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;lineHeight&lt;/tt&gt;&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		///
		///
		/// &lt;li&gt;&lt;u&gt;Animation Property Attributes&lt;/u&gt;&lt;/li&gt;
		///
		/// &lt;p&gt;Each Animation Property is a config object with optional properties:&lt;/p&gt;
		/// &lt;div&gt;&lt;ul class=&quot;mdetail-params&quot;&gt;
		/// &lt;li&gt;&lt;tt&gt;by&lt;/tt&gt;* : relative change - start at current value, change by this value&lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;from&lt;/tt&gt; : ignore current value, start from this value&lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;to&lt;/tt&gt;* : start at current value, go to this value&lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;unit&lt;/tt&gt; : any allowable unit specification&lt;/li&gt;
		/// &lt;p&gt;* do not specify both &lt;tt&gt;to&lt;/tt&gt; and &lt;tt&gt;by&lt;/tt&gt; for an animation property&lt;/p&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		///
		/// &lt;li&gt;&lt;u&gt;Animation Types&lt;/u&gt;&lt;/li&gt;
		///
		/// &lt;p&gt;The supported animation types:&lt;/p&gt;&lt;div&gt;&lt;ul class=&quot;mdetail-params&quot;&gt;
		/// &lt;li&gt;&lt;tt&gt;&apos;run&apos;&lt;/tt&gt; : Default
		/// &lt;pre&gt;&lt;code&gt;
		/// var el = Ext.get(&apos;complexEl&apos;);
		/// el.animate(
		/// // animation control object
		/// {
		/// borderWidth: {to: 3, from: 0},
		/// opacity: {to: .3, from: 1},
		/// height: {to: 50, from: el.getHeight()},
		/// width: {to: 300, from: el.getWidth()},
		/// top : {by: - 100, unit: &apos;px&apos;},
		/// },
		/// 0.35, // animation duration
		/// null, // callback
		/// &apos;easeOut&apos;, // easing method
		/// &apos;run&apos; // animation type (&apos;run&apos;,&apos;color&apos;,&apos;motion&apos;,&apos;scroll&apos;)
		/// );
		/// &lt;/code&gt;&lt;/pre&gt;
		/// &lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;&apos;color&apos;&lt;/tt&gt;
		/// &lt;p&gt;Animates transition of background, text, or border colors.&lt;/p&gt;
		/// &lt;pre&gt;&lt;code&gt;
		/// el.animate(
		/// // animation control object
		/// {
		/// color: { to: &apos;#06e&apos; },
		/// backgroundColor: { to: &apos;#e06&apos; }
		/// },
		/// 0.35, // animation duration
		/// null, // callback
		/// &apos;easeOut&apos;, // easing method
		/// &apos;color&apos; // animation type (&apos;run&apos;,&apos;color&apos;,&apos;motion&apos;,&apos;scroll&apos;)
		/// );
		/// &lt;/code&gt;&lt;/pre&gt;
		/// &lt;/li&gt;
		///
		/// &lt;li&gt;&lt;tt&gt;&apos;motion&apos;&lt;/tt&gt;
		/// &lt;p&gt;Animates the motion of an element to/from specific points using optional bezier
		/// way points during transit.&lt;/p&gt;
		/// &lt;pre&gt;&lt;code&gt;
		/// el.animate(
		/// // animation control object
		/// {
		/// borderWidth: {to: 3, from: 0},
		/// opacity: {to: .3, from: 1},
		/// height: {to: 50, from: el.getHeight()},
		/// width: {to: 300, from: el.getWidth()},
		/// top : {by: - 100, unit: &apos;px&apos;},
		/// points: {
		/// to: [50, 100], // go to this point
		/// control: [ // optional bezier way points
		/// [ 600, 800],
		/// [-100, 200]
		/// ]
		/// }
		/// },
		/// 3000, // animation duration (milliseconds!)
		/// null, // callback
		/// &apos;easeOut&apos;, // easing method
		/// &apos;motion&apos; // animation type (&apos;run&apos;,&apos;color&apos;,&apos;motion&apos;,&apos;scroll&apos;)
		/// );
		/// &lt;/code&gt;&lt;/pre&gt;
		/// &lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;&apos;scroll&apos;&lt;/tt&gt;
		/// &lt;p&gt;Animate horizontal or vertical scrolling of an overflowing page element.&lt;/p&gt;
		/// &lt;pre&gt;&lt;code&gt;
		/// el.animate(
		/// // animation control object
		/// {
		/// scroll: {to: [400, 300]}
		/// },
		/// 0.35, // animation duration
		/// null, // callback
		/// &apos;easeOut&apos;, // easing method
		/// &apos;scroll&apos; // animation type (&apos;run&apos;,&apos;color&apos;,&apos;motion&apos;,&apos;scroll&apos;)
		/// );
		/// &lt;/code&gt;&lt;/pre&gt;
		/// &lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		///
		/// &lt;/ul&gt;&lt;/div&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Element.fx.js</definedin>
		/// <param name="args">The animation control args</param>
		/// <param name="duration">How long the animation lasts in seconds (defaults to &lt;tt&gt;.35&lt;/tt&gt;)</param>
		/// <param name="onComplete">Function to call when animation completes</param>
		/// <returns>this</returns>
		[ScriptName("animate")]
		public ext.Element Animate(object args, float duration, System.Delegate onComplete)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Perform custom animation on this element.
		///   Animation Properties  The Animation Control Object enables gradual transitions for any member of an
		/// element&apos;s style object that takes a numeric value including but not limited to
		/// these properties:    bottom, top, left, right  height, width  margin, padding  borderWidth  opacity  fontSize  lineHeight    Animation Property Attributes  Each Animation Property is a config object with optional properties:    by* : relative change - start at current value, change by this value  from : ignore current value, start from this value  to* : start at current value, go to this value  unit : any allowable unit specification  * do not specify both to and by for an animation property    Animation Types  The supported animation types:    &apos;run&apos; : Default
		/// 
		/// var el = Ext.get(&apos;complexEl&apos;);
		/// el.animate(
		/// // animation control object
		/// {
		/// borderWidth: {to: 3, from: 0},
		/// opacity: {to: .3, from: 1},
		/// height: {to: 50, from: el.getHeight()},
		/// width: {to: 300,...
		/// </summary>
		/// <htmlSummary>
		/// Perform custom animation on this element.
		/// &lt;div&gt;&lt;ul class=&quot;mdetail-params&quot;&gt;
		/// &lt;li&gt;&lt;u&gt;Animation Properties&lt;/u&gt;&lt;/li&gt;
		///
		/// &lt;p&gt;The Animation Control Object enables gradual transitions for any member of an
		/// element&apos;s style object that takes a numeric value including but not limited to
		/// these properties:&lt;/p&gt;&lt;div&gt;&lt;ul class=&quot;mdetail-params&quot;&gt;
		/// &lt;li&gt;&lt;tt&gt;bottom, top, left, right&lt;/tt&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;height, width&lt;/tt&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;margin, padding&lt;/tt&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;borderWidth&lt;/tt&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;opacity&lt;/tt&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;fontSize&lt;/tt&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;lineHeight&lt;/tt&gt;&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		///
		///
		/// &lt;li&gt;&lt;u&gt;Animation Property Attributes&lt;/u&gt;&lt;/li&gt;
		///
		/// &lt;p&gt;Each Animation Property is a config object with optional properties:&lt;/p&gt;
		/// &lt;div&gt;&lt;ul class=&quot;mdetail-params&quot;&gt;
		/// &lt;li&gt;&lt;tt&gt;by&lt;/tt&gt;* : relative change - start at current value, change by this value&lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;from&lt;/tt&gt; : ignore current value, start from this value&lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;to&lt;/tt&gt;* : start at current value, go to this value&lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;unit&lt;/tt&gt; : any allowable unit specification&lt;/li&gt;
		/// &lt;p&gt;* do not specify both &lt;tt&gt;to&lt;/tt&gt; and &lt;tt&gt;by&lt;/tt&gt; for an animation property&lt;/p&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		///
		/// &lt;li&gt;&lt;u&gt;Animation Types&lt;/u&gt;&lt;/li&gt;
		///
		/// &lt;p&gt;The supported animation types:&lt;/p&gt;&lt;div&gt;&lt;ul class=&quot;mdetail-params&quot;&gt;
		/// &lt;li&gt;&lt;tt&gt;&apos;run&apos;&lt;/tt&gt; : Default
		/// &lt;pre&gt;&lt;code&gt;
		/// var el = Ext.get(&apos;complexEl&apos;);
		/// el.animate(
		/// // animation control object
		/// {
		/// borderWidth: {to: 3, from: 0},
		/// opacity: {to: .3, from: 1},
		/// height: {to: 50, from: el.getHeight()},
		/// width: {to: 300, from: el.getWidth()},
		/// top : {by: - 100, unit: &apos;px&apos;},
		/// },
		/// 0.35, // animation duration
		/// null, // callback
		/// &apos;easeOut&apos;, // easing method
		/// &apos;run&apos; // animation type (&apos;run&apos;,&apos;color&apos;,&apos;motion&apos;,&apos;scroll&apos;)
		/// );
		/// &lt;/code&gt;&lt;/pre&gt;
		/// &lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;&apos;color&apos;&lt;/tt&gt;
		/// &lt;p&gt;Animates transition of background, text, or border colors.&lt;/p&gt;
		/// &lt;pre&gt;&lt;code&gt;
		/// el.animate(
		/// // animation control object
		/// {
		/// color: { to: &apos;#06e&apos; },
		/// backgroundColor: { to: &apos;#e06&apos; }
		/// },
		/// 0.35, // animation duration
		/// null, // callback
		/// &apos;easeOut&apos;, // easing method
		/// &apos;color&apos; // animation type (&apos;run&apos;,&apos;color&apos;,&apos;motion&apos;,&apos;scroll&apos;)
		/// );
		/// &lt;/code&gt;&lt;/pre&gt;
		/// &lt;/li&gt;
		///
		/// &lt;li&gt;&lt;tt&gt;&apos;motion&apos;&lt;/tt&gt;
		/// &lt;p&gt;Animates the motion of an element to/from specific points using optional bezier
		/// way points during transit.&lt;/p&gt;
		/// &lt;pre&gt;&lt;code&gt;
		/// el.animate(
		/// // animation control object
		/// {
		/// borderWidth: {to: 3, from: 0},
		/// opacity: {to: .3, from: 1},
		/// height: {to: 50, from: el.getHeight()},
		/// width: {to: 300, from: el.getWidth()},
		/// top : {by: - 100, unit: &apos;px&apos;},
		/// points: {
		/// to: [50, 100], // go to this point
		/// control: [ // optional bezier way points
		/// [ 600, 800],
		/// [-100, 200]
		/// ]
		/// }
		/// },
		/// 3000, // animation duration (milliseconds!)
		/// null, // callback
		/// &apos;easeOut&apos;, // easing method
		/// &apos;motion&apos; // animation type (&apos;run&apos;,&apos;color&apos;,&apos;motion&apos;,&apos;scroll&apos;)
		/// );
		/// &lt;/code&gt;&lt;/pre&gt;
		/// &lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;&apos;scroll&apos;&lt;/tt&gt;
		/// &lt;p&gt;Animate horizontal or vertical scrolling of an overflowing page element.&lt;/p&gt;
		/// &lt;pre&gt;&lt;code&gt;
		/// el.animate(
		/// // animation control object
		/// {
		/// scroll: {to: [400, 300]}
		/// },
		/// 0.35, // animation duration
		/// null, // callback
		/// &apos;easeOut&apos;, // easing method
		/// &apos;scroll&apos; // animation type (&apos;run&apos;,&apos;color&apos;,&apos;motion&apos;,&apos;scroll&apos;)
		/// );
		/// &lt;/code&gt;&lt;/pre&gt;
		/// &lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		///
		/// &lt;/ul&gt;&lt;/div&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Element.fx.js</definedin>
		/// <param name="args">The animation control args</param>
		/// <param name="duration">How long the animation lasts in seconds (defaults to &lt;tt&gt;.35&lt;/tt&gt;)</param>
		/// <returns>this</returns>
		[ScriptName("animate")]
		public ext.Element Animate(object args, float duration)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Perform custom animation on this element.
		///   Animation Properties  The Animation Control Object enables gradual transitions for any member of an
		/// element&apos;s style object that takes a numeric value including but not limited to
		/// these properties:    bottom, top, left, right  height, width  margin, padding  borderWidth  opacity  fontSize  lineHeight    Animation Property Attributes  Each Animation Property is a config object with optional properties:    by* : relative change - start at current value, change by this value  from : ignore current value, start from this value  to* : start at current value, go to this value  unit : any allowable unit specification  * do not specify both to and by for an animation property    Animation Types  The supported animation types:    &apos;run&apos; : Default
		/// 
		/// var el = Ext.get(&apos;complexEl&apos;);
		/// el.animate(
		/// // animation control object
		/// {
		/// borderWidth: {to: 3, from: 0},
		/// opacity: {to: .3, from: 1},
		/// height: {to: 50, from: el.getHeight()},
		/// width: {to: 300,...
		/// </summary>
		/// <htmlSummary>
		/// Perform custom animation on this element.
		/// &lt;div&gt;&lt;ul class=&quot;mdetail-params&quot;&gt;
		/// &lt;li&gt;&lt;u&gt;Animation Properties&lt;/u&gt;&lt;/li&gt;
		///
		/// &lt;p&gt;The Animation Control Object enables gradual transitions for any member of an
		/// element&apos;s style object that takes a numeric value including but not limited to
		/// these properties:&lt;/p&gt;&lt;div&gt;&lt;ul class=&quot;mdetail-params&quot;&gt;
		/// &lt;li&gt;&lt;tt&gt;bottom, top, left, right&lt;/tt&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;height, width&lt;/tt&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;margin, padding&lt;/tt&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;borderWidth&lt;/tt&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;opacity&lt;/tt&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;fontSize&lt;/tt&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;lineHeight&lt;/tt&gt;&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		///
		///
		/// &lt;li&gt;&lt;u&gt;Animation Property Attributes&lt;/u&gt;&lt;/li&gt;
		///
		/// &lt;p&gt;Each Animation Property is a config object with optional properties:&lt;/p&gt;
		/// &lt;div&gt;&lt;ul class=&quot;mdetail-params&quot;&gt;
		/// &lt;li&gt;&lt;tt&gt;by&lt;/tt&gt;* : relative change - start at current value, change by this value&lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;from&lt;/tt&gt; : ignore current value, start from this value&lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;to&lt;/tt&gt;* : start at current value, go to this value&lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;unit&lt;/tt&gt; : any allowable unit specification&lt;/li&gt;
		/// &lt;p&gt;* do not specify both &lt;tt&gt;to&lt;/tt&gt; and &lt;tt&gt;by&lt;/tt&gt; for an animation property&lt;/p&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		///
		/// &lt;li&gt;&lt;u&gt;Animation Types&lt;/u&gt;&lt;/li&gt;
		///
		/// &lt;p&gt;The supported animation types:&lt;/p&gt;&lt;div&gt;&lt;ul class=&quot;mdetail-params&quot;&gt;
		/// &lt;li&gt;&lt;tt&gt;&apos;run&apos;&lt;/tt&gt; : Default
		/// &lt;pre&gt;&lt;code&gt;
		/// var el = Ext.get(&apos;complexEl&apos;);
		/// el.animate(
		/// // animation control object
		/// {
		/// borderWidth: {to: 3, from: 0},
		/// opacity: {to: .3, from: 1},
		/// height: {to: 50, from: el.getHeight()},
		/// width: {to: 300, from: el.getWidth()},
		/// top : {by: - 100, unit: &apos;px&apos;},
		/// },
		/// 0.35, // animation duration
		/// null, // callback
		/// &apos;easeOut&apos;, // easing method
		/// &apos;run&apos; // animation type (&apos;run&apos;,&apos;color&apos;,&apos;motion&apos;,&apos;scroll&apos;)
		/// );
		/// &lt;/code&gt;&lt;/pre&gt;
		/// &lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;&apos;color&apos;&lt;/tt&gt;
		/// &lt;p&gt;Animates transition of background, text, or border colors.&lt;/p&gt;
		/// &lt;pre&gt;&lt;code&gt;
		/// el.animate(
		/// // animation control object
		/// {
		/// color: { to: &apos;#06e&apos; },
		/// backgroundColor: { to: &apos;#e06&apos; }
		/// },
		/// 0.35, // animation duration
		/// null, // callback
		/// &apos;easeOut&apos;, // easing method
		/// &apos;color&apos; // animation type (&apos;run&apos;,&apos;color&apos;,&apos;motion&apos;,&apos;scroll&apos;)
		/// );
		/// &lt;/code&gt;&lt;/pre&gt;
		/// &lt;/li&gt;
		///
		/// &lt;li&gt;&lt;tt&gt;&apos;motion&apos;&lt;/tt&gt;
		/// &lt;p&gt;Animates the motion of an element to/from specific points using optional bezier
		/// way points during transit.&lt;/p&gt;
		/// &lt;pre&gt;&lt;code&gt;
		/// el.animate(
		/// // animation control object
		/// {
		/// borderWidth: {to: 3, from: 0},
		/// opacity: {to: .3, from: 1},
		/// height: {to: 50, from: el.getHeight()},
		/// width: {to: 300, from: el.getWidth()},
		/// top : {by: - 100, unit: &apos;px&apos;},
		/// points: {
		/// to: [50, 100], // go to this point
		/// control: [ // optional bezier way points
		/// [ 600, 800],
		/// [-100, 200]
		/// ]
		/// }
		/// },
		/// 3000, // animation duration (milliseconds!)
		/// null, // callback
		/// &apos;easeOut&apos;, // easing method
		/// &apos;motion&apos; // animation type (&apos;run&apos;,&apos;color&apos;,&apos;motion&apos;,&apos;scroll&apos;)
		/// );
		/// &lt;/code&gt;&lt;/pre&gt;
		/// &lt;/li&gt;
		/// &lt;li&gt;&lt;tt&gt;&apos;scroll&apos;&lt;/tt&gt;
		/// &lt;p&gt;Animate horizontal or vertical scrolling of an overflowing page element.&lt;/p&gt;
		/// &lt;pre&gt;&lt;code&gt;
		/// el.animate(
		/// // animation control object
		/// {
		/// scroll: {to: [400, 300]}
		/// },
		/// 0.35, // animation duration
		/// null, // callback
		/// &apos;easeOut&apos;, // easing method
		/// &apos;scroll&apos; // animation type (&apos;run&apos;,&apos;color&apos;,&apos;motion&apos;,&apos;scroll&apos;)
		/// );
		/// &lt;/code&gt;&lt;/pre&gt;
		/// &lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		///
		/// &lt;/ul&gt;&lt;/div&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Element.fx.js</definedin>
		/// <param name="args">The animation control args</param>
		/// <returns>this</returns>
		[ScriptName("animate")]
		public ext.Element Animate(object args)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Sets the visibility of the element (see details). If the visibilityMode is set to Element.DISPLAY, it will use
		/// the display property to hide the element, otherwise it uses visibility. The default is to hide and show using the visibility property.
		/// </summary>
		/// <definedin>src\ext-core\src\core\Element.fx.js</definedin>
		/// <param name="visible">Whether the element is visible</param>
		/// <param name="animate">True for the default animation, or a standard Element animation config object</param>
		/// <returns>this</returns>
		[ScriptName("setVisible")]
		public ext.Element SetVisible(bool visible, bool animate)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Sets the visibility of the element (see details). If the visibilityMode is set to Element.DISPLAY, it will use
		/// the display property to hide the element, otherwise it uses visibility. The default is to hide and show using the visibility property.
		/// </summary>
		/// <definedin>src\ext-core\src\core\Element.fx.js</definedin>
		/// <param name="visible">Whether the element is visible</param>
		/// <param name="animate">True for the default animation, or a standard Element animation config object</param>
		/// <returns>this</returns>
		[ScriptName("setVisible")]
		public ext.Element SetVisible(bool visible, object animate)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Sets the visibility of the element (see details). If the visibilityMode is set to Element.DISPLAY, it will use
		/// the display property to hide the element, otherwise it uses visibility. The default is to hide and show using the visibility property.
		/// </summary>
		/// <definedin>src\ext-core\src\core\Element.fx.js</definedin>
		/// <param name="visible">Whether the element is visible</param>
		/// <returns>this</returns>
		[ScriptName("setVisible")]
		public ext.Element SetVisible(bool visible)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Toggles the element&apos;s visibility or display, depending on visibility mode.</summary>
		/// <definedin>src\ext-core\src\core\Element.fx.js</definedin>
		/// <param name="animate">True for the default animation, or a standard Element animation config object</param>
		/// <returns>this</returns>
		[ScriptName("toggle")]
		public ext.Element Toggle(bool animate)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Toggles the element&apos;s visibility or display, depending on visibility mode.</summary>
		/// <definedin>src\ext-core\src\core\Element.fx.js</definedin>
		/// <param name="animate">True for the default animation, or a standard Element animation config object</param>
		/// <returns>this</returns>
		[ScriptName("toggle")]
		public ext.Element Toggle(object animate)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Toggles the element&apos;s visibility or display, depending on visibility mode.</summary>
		/// <definedin>src\ext-core\src\core\Element.fx.js</definedin>
		/// <returns>this</returns>
		[ScriptName("toggle")]
		public ext.Element Toggle()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Hide this element - Uses display mode to determine whether to use &quot;display&quot; or &quot;visibility&quot;. See {@link #setVisible}.</summary>
		/// <definedin>src\ext-core\src\core\Element.fx.js</definedin>
		/// <param name="animate">true for the default animation or a standard Element animation config object</param>
		/// <returns>this</returns>
		[ScriptName("hide")]
		public ext.Element Hide(bool animate)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Hide this element - Uses display mode to determine whether to use &quot;display&quot; or &quot;visibility&quot;. See {@link #setVisible}.</summary>
		/// <definedin>src\ext-core\src\core\Element.fx.js</definedin>
		/// <param name="animate">true for the default animation or a standard Element animation config object</param>
		/// <returns>this</returns>
		[ScriptName("hide")]
		public ext.Element Hide(object animate)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Hide this element - Uses display mode to determine whether to use &quot;display&quot; or &quot;visibility&quot;. See {@link #setVisible}.</summary>
		/// <definedin>src\ext-core\src\core\Element.fx.js</definedin>
		/// <returns>this</returns>
		[ScriptName("hide")]
		public ext.Element Hide()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Show this element - Uses display mode to determine whether to use &quot;display&quot; or &quot;visibility&quot;. See {@link #setVisible}.</summary>
		/// <definedin>src\ext-core\src\core\Element.fx.js</definedin>
		/// <param name="animate">true for the default animation or a standard Element animation config object</param>
		/// <returns>this</returns>
		[ScriptName("show")]
		public ext.Element Show(bool animate)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Show this element - Uses display mode to determine whether to use &quot;display&quot; or &quot;visibility&quot;. See {@link #setVisible}.</summary>
		/// <definedin>src\ext-core\src\core\Element.fx.js</definedin>
		/// <param name="animate">true for the default animation or a standard Element animation config object</param>
		/// <returns>this</returns>
		[ScriptName("show")]
		public ext.Element Show(object animate)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Show this element - Uses display mode to determine whether to use &quot;display&quot; or &quot;visibility&quot;. See {@link #setVisible}.</summary>
		/// <definedin>src\ext-core\src\core\Element.fx.js</definedin>
		/// <returns>this</returns>
		[ScriptName("show")]
		public ext.Element Show()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Appends the passed element(s) to this element</summary>
		/// <definedin>src\ext-core\src\core\Element.insertion.js</definedin>
		/// <param name="el"></param>
		/// <returns>this</returns>
		[ScriptName("appendChild")]
		public ext.Element AppendChild(string el)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Appends the passed element(s) to this element</summary>
		/// <definedin>src\ext-core\src\core\Element.insertion.js</definedin>
		/// <param name="el"></param>
		/// <returns>this</returns>
		[ScriptName("appendChild")]
		public ext.Element AppendChild(System.Html.Element el)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Appends the passed element(s) to this element</summary>
		/// <definedin>src\ext-core\src\core\Element.insertion.js</definedin>
		/// <param name="el"></param>
		/// <returns>this</returns>
		[ScriptName("appendChild")]
		public ext.Element AppendChild(System.Array el)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Appends the passed element(s) to this element</summary>
		/// <definedin>src\ext-core\src\core\Element.insertion.js</definedin>
		/// <param name="el"></param>
		/// <returns>this</returns>
		[ScriptName("appendChild")]
		public ext.Element AppendChild(ext.Element el)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Appends the passed element(s) to this element</summary>
		/// <definedin>src\ext-core\src\core\Element.insertion.js</definedin>
		/// <param name="el"></param>
		/// <returns>this</returns>
		[ScriptName("appendChild")]
		public ext.Element AppendChild(ext.CompositeElement el)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Creates the passed DomHelper config and appends it to this element or optionally inserts it before the passed child element.</summary>
		/// <definedin>src\ext-core\src\core\Element.insertion.js</definedin>
		/// <param name="config">
		/// DomHelper element config object. If no tag is specified (e.g., {tag:&apos;input&apos;}) then a div will be
		/// automatically generated with the specified attributes.
		/// </param>
		/// <param name="insertBefore">a child element of this element</param>
		/// <param name="returnDom">true to return the dom node instead of creating an Element</param>
		/// <returns>The new child element</returns>
		[ScriptName("createChild")]
		public ext.Element CreateChild(object config, System.Html.Element insertBefore, bool returnDom)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Creates the passed DomHelper config and appends it to this element or optionally inserts it before the passed child element.</summary>
		/// <definedin>src\ext-core\src\core\Element.insertion.js</definedin>
		/// <param name="config">
		/// DomHelper element config object. If no tag is specified (e.g., {tag:&apos;input&apos;}) then a div will be
		/// automatically generated with the specified attributes.
		/// </param>
		/// <param name="insertBefore">a child element of this element</param>
		/// <returns>The new child element</returns>
		[ScriptName("createChild")]
		public ext.Element CreateChild(object config, System.Html.Element insertBefore)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Creates the passed DomHelper config and appends it to this element or optionally inserts it before the passed child element.</summary>
		/// <definedin>src\ext-core\src\core\Element.insertion.js</definedin>
		/// <param name="config">
		/// DomHelper element config object. If no tag is specified (e.g., {tag:&apos;input&apos;}) then a div will be
		/// automatically generated with the specified attributes.
		/// </param>
		/// <returns>The new child element</returns>
		[ScriptName("createChild")]
		public ext.Element CreateChild(object config)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Creates and wraps this element with another element</summary>
		/// <definedin>src\ext-core\src\core\Element.insertion.js</definedin>
		/// <param name="config">DomHelper element config object for the wrapper element or null for an empty div</param>
		/// <param name="returnDom">True to return the raw DOM element instead of Ext.Element</param>
		/// <returns>The newly created wrapper element</returns>
		[ScriptName("wrap")]
		public ext.auto.System_Html_Element_Or_ext_Element Wrap(object config, bool returnDom)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Creates and wraps this element with another element</summary>
		/// <definedin>src\ext-core\src\core\Element.insertion.js</definedin>
		/// <param name="config">DomHelper element config object for the wrapper element or null for an empty div</param>
		/// <returns>The newly created wrapper element</returns>
		[ScriptName("wrap")]
		public ext.auto.System_Html_Element_Or_ext_Element Wrap(object config)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Creates and wraps this element with another element</summary>
		/// <definedin>src\ext-core\src\core\Element.insertion.js</definedin>
		/// <returns>The newly created wrapper element</returns>
		[ScriptName("wrap")]
		public ext.auto.System_Html_Element_Or_ext_Element Wrap()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Inserts an html fragment into this element</summary>
		/// <definedin>src\ext-core\src\core\Element.insertion.js</definedin>
		/// <param name="where">Where to insert the html in relation to this element - beforeBegin, afterBegin, beforeEnd, afterEnd.</param>
		/// <param name="html">The HTML fragment</param>
		/// <param name="returnEl">True to return an Ext.Element (defaults to false)</param>
		/// <returns>The inserted node (or nearest related if more than 1 inserted)</returns>
		[ScriptName("insertHtml")]
		public ext.auto.System_Html_Element_Or_ext_Element InsertHtml(string where, string html, bool returnEl)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Inserts an html fragment into this element</summary>
		/// <definedin>src\ext-core\src\core\Element.insertion.js</definedin>
		/// <param name="where">Where to insert the html in relation to this element - beforeBegin, afterBegin, beforeEnd, afterEnd.</param>
		/// <param name="html">The HTML fragment</param>
		/// <returns>The inserted node (or nearest related if more than 1 inserted)</returns>
		[ScriptName("insertHtml")]
		public ext.auto.System_Html_Element_Or_ext_Element InsertHtml(string where, string html)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Sets the passed attributes as attributes of this element (a style attribute can be a string, object or function)</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		/// <param name="o">The object with the attributes</param>
		/// <param name="useSet">false to override the default setAttribute to use expandos.</param>
		/// <returns>this</returns>
		[ScriptName("set")]
		public ext.Element Set(object o, bool useSet)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Sets the passed attributes as attributes of this element (a style attribute can be a string, object or function)</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		/// <param name="o">The object with the attributes</param>
		/// <returns>this</returns>
		[ScriptName("set")]
		public ext.Element Set(object o)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Tries to focus the element. Any exceptions are caught and ignored.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		/// <param name="defer">Milliseconds to defer the focus</param>
		/// <returns>this</returns>
		[ScriptName("focus")]
		public ext.Element FocusMethod(System.Number defer)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Tries to focus the element. Any exceptions are caught and ignored.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		/// <returns>this</returns>
		[ScriptName("focus")]
		public ext.Element FocusMethod()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Appends an event handler to this element. The shorthand version {@link #on} is equivalent.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		/// <param name="eventName">The name of event to handle.</param>
		/// <param name="fn">
		/// The handler function the event invokes. This function is passed
		/// the following parameters:&lt;ul&gt;
		/// &lt;li&gt;&lt;b&gt;evt&lt;/b&gt; : EventObject&lt;div class=&quot;sub-desc&quot;&gt;The {@link Ext.EventObject EventObject} describing the event.&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;el&lt;/b&gt; : HtmlElement&lt;div class=&quot;sub-desc&quot;&gt;The DOM element which was the target of the event.
		/// Note that this may be filtered by using the &lt;tt&gt;delegate&lt;/tt&gt; option.&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;o&lt;/b&gt; : Object&lt;div class=&quot;sub-desc&quot;&gt;The options object from the addListener call.&lt;/div&gt;&lt;/li&gt;
		/// &lt;/ul&gt;
		/// </param>
		/// <param name="scope">
		/// The scope (<c>&lt;b&gt;this&lt;/b&gt;</c> reference) in which the handler function is executed.
		/// &lt;b&gt;If omitted, defaults to this Element.&lt;/b&gt;.
		/// </param>
		/// <param name="options">
		/// An object containing handler configuration properties.
		/// This may contain any of the following properties:&lt;ul&gt;
		/// &lt;li&gt;&lt;b&gt;scope&lt;/b&gt; Object : &lt;div class=&quot;sub-desc&quot;&gt;The scope (<c>&lt;b&gt;this&lt;/b&gt;</c> reference) in which the handler function is executed.
		/// &lt;b&gt;If omitted, defaults to this Element.&lt;/b&gt;&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;delegate&lt;/b&gt; String: &lt;div class=&quot;sub-desc&quot;&gt;A simple selector to filter the target or look for a descendant of the target. See below for additional details.&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;stopEvent&lt;/b&gt; Boolean: &lt;div class=&quot;sub-desc&quot;&gt;True to stop the event. That is stop propagation, and prevent the default action.&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;preventDefault&lt;/b&gt; Boolean: &lt;div class=&quot;sub-desc&quot;&gt;True to prevent the default action&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;stopPropagation&lt;/b&gt; Boolean: &lt;div class=&quot;sub-desc&quot;&gt;True to prevent event propagation&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;normalized&lt;/b&gt; Boolean: &lt;div class=&quot;sub-desc&quot;&gt;False to pass a browser event to the handler function instead of an Ext.EventObject&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;target&lt;/b&gt; Ext.Element: &lt;div class=&quot;sub-desc&quot;&gt;Only call the handler if the event was fired on the target Element, &lt;i&gt;not&lt;/i&gt; if the event was bubbled up from a child node.&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;delay&lt;/b&gt; Number: &lt;div class=&quot;sub-desc&quot;&gt;The number of milliseconds to delay the invocation of the handler after the event fires.&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;single&lt;/b&gt; Boolean: &lt;div class=&quot;sub-desc&quot;&gt;True to add a handler to handle just the next firing of the event, and then remove itself.&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;buffer&lt;/b&gt; Number: &lt;div class=&quot;sub-desc&quot;&gt;Causes the handler to be scheduled to run in an {@link Ext.util.DelayedTask} delayed
		/// by the specified number of milliseconds. If the event fires again within that time, the original
		/// handler is &lt;em&gt;not&lt;/em&gt; invoked, but the new handler is scheduled in its place.&lt;/div&gt;&lt;/li&gt;
		/// &lt;/ul&gt;&lt;br&gt;
		/// &lt;p&gt;
		/// &lt;b&gt;Combining Options&lt;/b&gt;&lt;br&gt;
		/// In the following examples, the shorthand form {@link #on} is used rather than the more verbose
		/// addListener. The two are equivalent. Using the options argument, it is possible to combine different
		/// types of listeners:&lt;br&gt;
		/// &lt;br&gt;
		/// A delayed, one-time listener that auto stops the event and adds a custom argument (forumId) to the
		/// options object. The options object is available as the third parameter in the handler function.&lt;div style=&quot;margin: 5px 20px 20px;&quot;&gt;
		/// Code:<c>
		/// el.on(&apos;click&apos;, this.onClick, this, {
		/// single: true,
		/// delay: 100,
		/// stopEvent : true,
		/// forumId: 4
		/// });</c>&lt;/pre&gt;&lt;/p&gt;
		/// &lt;p&gt;
		/// &lt;b&gt;Attaching multiple handlers in 1 call&lt;/b&gt;&lt;br&gt;
		/// The method also allows for a single argument to be passed which is a config object containing properties
		/// which specify multiple handlers.&lt;/p&gt;
		/// &lt;p&gt;
		/// Code:<c>
		/// el.on({
		/// &apos;click&apos; : {
		/// fn: this.onClick,
		/// scope: this,
		/// delay: 100
		/// },
		/// &apos;mouseover&apos; : {
		/// fn: this.onMouseOver,
		/// scope: this
		/// },
		/// &apos;mouseout&apos; : {
		/// fn: this.onMouseOut,
		/// scope: this
		/// }
		/// });</c>&lt;/pre&gt;
		/// &lt;p&gt;
		/// Or a shorthand syntax:&lt;br&gt;
		/// Code:<c>&lt;/p&gt;
		/// el.on({
		/// &apos;click&apos; : this.onClick,
		/// &apos;mouseover&apos; : this.onMouseOver,
		/// &apos;mouseout&apos; : this.onMouseOut,
		/// scope: this
		/// });
		/// </c>&lt;/pre&gt;&lt;/p&gt;
		/// &lt;p&gt;&lt;b&gt;delegate&lt;/b&gt;&lt;/p&gt;
		/// &lt;p&gt;This is a configuration option that you can pass along when registering a handler for
		/// an event to assist with event delegation. Event delegation is a technique that is used to
		/// reduce memory consumption and prevent exposure to memory-leaks. By registering an event
		/// for a container element as opposed to each element within a container. By setting this
		/// configuration option to a simple selector, the target element will be filtered to look for
		/// a descendant of the target.
		/// For example:<c>
		/// // using this markup:
		/// &amp;lt;div id=&apos;elId&apos;&gt;
		/// &amp;lt;p id=&apos;p1&apos;&gt;paragraph one&amp;lt;/p&gt;
		/// &amp;lt;p id=&apos;p2&apos; class=&apos;clickable&apos;&gt;paragraph two&amp;lt;/p&gt;
		/// &amp;lt;p id=&apos;p3&apos;&gt;paragraph three&amp;lt;/p&gt;
		/// &amp;lt;/div&gt;
		/// // utilize event delegation to registering just one handler on the container element:
		/// el = Ext.get(&apos;elId&apos;);
		/// el.on(
		/// &apos;click&apos;,
		/// function(e,t) {
		/// // handle click
		/// console.info(t.id); // &apos;p2&apos;
		/// },
		/// this,
		/// {
		/// // filter the target element to be a descendant with the class &apos;clickable&apos;
		/// delegate: &apos;.clickable&apos;
		/// }
		/// );
		/// </c>&lt;/pre&gt;&lt;/p&gt;
		/// </param>
		/// <returns>this</returns>
		[ScriptName("addListener")]
		public ext.Element AddListener(string eventName, System.Delegate fn, object scope, object options)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Appends an event handler to this element. The shorthand version {@link #on} is equivalent.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		/// <param name="eventName">The name of event to handle.</param>
		/// <param name="fn">
		/// The handler function the event invokes. This function is passed
		/// the following parameters:&lt;ul&gt;
		/// &lt;li&gt;&lt;b&gt;evt&lt;/b&gt; : EventObject&lt;div class=&quot;sub-desc&quot;&gt;The {@link Ext.EventObject EventObject} describing the event.&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;el&lt;/b&gt; : HtmlElement&lt;div class=&quot;sub-desc&quot;&gt;The DOM element which was the target of the event.
		/// Note that this may be filtered by using the &lt;tt&gt;delegate&lt;/tt&gt; option.&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;o&lt;/b&gt; : Object&lt;div class=&quot;sub-desc&quot;&gt;The options object from the addListener call.&lt;/div&gt;&lt;/li&gt;
		/// &lt;/ul&gt;
		/// </param>
		/// <param name="scope">
		/// The scope (<c>&lt;b&gt;this&lt;/b&gt;</c> reference) in which the handler function is executed.
		/// &lt;b&gt;If omitted, defaults to this Element.&lt;/b&gt;.
		/// </param>
		/// <returns>this</returns>
		[ScriptName("addListener")]
		public ext.Element AddListener(string eventName, System.Delegate fn, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Appends an event handler to this element. The shorthand version {@link #on} is equivalent.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		/// <param name="eventName">The name of event to handle.</param>
		/// <param name="fn">
		/// The handler function the event invokes. This function is passed
		/// the following parameters:&lt;ul&gt;
		/// &lt;li&gt;&lt;b&gt;evt&lt;/b&gt; : EventObject&lt;div class=&quot;sub-desc&quot;&gt;The {@link Ext.EventObject EventObject} describing the event.&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;el&lt;/b&gt; : HtmlElement&lt;div class=&quot;sub-desc&quot;&gt;The DOM element which was the target of the event.
		/// Note that this may be filtered by using the &lt;tt&gt;delegate&lt;/tt&gt; option.&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;o&lt;/b&gt; : Object&lt;div class=&quot;sub-desc&quot;&gt;The options object from the addListener call.&lt;/div&gt;&lt;/li&gt;
		/// &lt;/ul&gt;
		/// </param>
		/// <returns>this</returns>
		[ScriptName("addListener")]
		public ext.Element AddListener(string eventName, System.Delegate fn)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Sets up event handlers to call the passed functions when the mouse is moved into and out of the Element.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		/// <param name="overFn">The function to call when the mouse enters the Element.</param>
		/// <param name="outFn">The function to call when the mouse leaves the Element.</param>
		/// <param name="scope">The scope (<c>this</c> reference) in which the functions are executed. Defaults to the Element&apos;s DOM element.</param>
		/// <param name="options">Options for the listener. See {@link Ext.util.Observable#addListener the &lt;tt&gt;options&lt;/tt&gt; parameter}.</param>
		/// <returns>this</returns>
		[ScriptName("hover")]
		public ext.Element Hover(System.Delegate overFn, System.Delegate outFn, object scope, object options)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Sets up event handlers to call the passed functions when the mouse is moved into and out of the Element.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		/// <param name="overFn">The function to call when the mouse enters the Element.</param>
		/// <param name="outFn">The function to call when the mouse leaves the Element.</param>
		/// <param name="scope">The scope (<c>this</c> reference) in which the functions are executed. Defaults to the Element&apos;s DOM element.</param>
		/// <returns>this</returns>
		[ScriptName("hover")]
		public ext.Element Hover(System.Delegate overFn, System.Delegate outFn, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Sets up event handlers to call the passed functions when the mouse is moved into and out of the Element.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		/// <param name="overFn">The function to call when the mouse enters the Element.</param>
		/// <param name="outFn">The function to call when the mouse leaves the Element.</param>
		/// <returns>this</returns>
		[ScriptName("hover")]
		public ext.Element Hover(System.Delegate overFn, System.Delegate outFn)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns true if this element is an ancestor of the passed element</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		/// <param name="el">The element to check</param>
		/// <returns>True if this element is an ancestor of el, else false</returns>
		[ScriptName("contains")]
		public bool Contains(System.Html.Element el)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns true if this element is an ancestor of the passed element</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		/// <param name="el">The element to check</param>
		/// <returns>True if this element is an ancestor of el, else false</returns>
		[ScriptName("contains")]
		public bool Contains(string el)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns the value of an attribute from the element&apos;s underlying DOM node.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		/// <param name="name">The attribute name</param>
		/// <param name="namespace">The namespace in which to look for the attribute</param>
		/// <returns>The attribute value</returns>
		[ScriptName("getAttribute")]
		public string GetAttribute(string name, string @namespace)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns the value of an attribute from the element&apos;s underlying DOM node.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		/// <param name="name">The attribute name</param>
		/// <returns>The attribute value</returns>
		[ScriptName("getAttribute")]
		public string GetAttribute(string name)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Appends an event handler (shorthand for {@link #addListener}).</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		/// <param name="eventName">The name of event to handle.</param>
		/// <param name="fn">The handler function the event invokes.</param>
		/// <param name="scope">The scope (<c>this</c> reference) in which the handler function is executed.</param>
		/// <param name="options">An object containing standard {@link #addListener} options</param>
		[ScriptName("on")]
		public static void On(string eventName, System.Delegate fn, object scope, object options)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Appends an event handler (shorthand for {@link #addListener}).</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		/// <param name="eventName">The name of event to handle.</param>
		/// <param name="fn">The handler function the event invokes.</param>
		/// <param name="scope">The scope (<c>this</c> reference) in which the handler function is executed.</param>
		[ScriptName("on")]
		public static void On(string eventName, System.Delegate fn, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Appends an event handler (shorthand for {@link #addListener}).</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		/// <param name="eventName">The name of event to handle.</param>
		/// <param name="fn">The handler function the event invokes.</param>
		[ScriptName("on")]
		public static void On(string eventName, System.Delegate fn)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Gets the globally shared flyweight Element, with the passed node as the active element. Do not store a reference to this element -
		/// the dom node can be overwritten by other code. Shorthand of {@link Ext.Element#fly}  Use this to make one-time references to DOM elements which are not going to be accessed again either by
		/// application code, or by Ext&apos;s classes. If accessing an element which will be processed regularly, then {@link Ext#get}
		/// will be more appropriate to take advantage of the caching provided by the Ext.Element class.
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Gets the globally shared flyweight Element, with the passed node as the active element. Do not store a reference to this element -
		/// the dom node can be overwritten by other code. Shorthand of {@link Ext.Element#fly}&lt;/p&gt;
		/// &lt;p&gt;Use this to make one-time references to DOM elements which are not going to be accessed again either by
		/// application code, or by Ext&apos;s classes. If accessing an element which will be processed regularly, then {@link Ext#get}
		/// will be more appropriate to take advantage of the caching provided by the Ext.Element class.&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		/// <param name="el">The dom node or id</param>
		/// <param name="named">
		/// Allows for creation of named reusable flyweights to prevent conflicts
		/// (e.g. internally Ext uses &quot;_global&quot;)
		/// </param>
		/// <returns>The shared Element object (or null if no matching element was found)</returns>
		[ScriptName("fly")]
		public static ext.Element Fly(string el, string named)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Gets the globally shared flyweight Element, with the passed node as the active element. Do not store a reference to this element -
		/// the dom node can be overwritten by other code. Shorthand of {@link Ext.Element#fly}  Use this to make one-time references to DOM elements which are not going to be accessed again either by
		/// application code, or by Ext&apos;s classes. If accessing an element which will be processed regularly, then {@link Ext#get}
		/// will be more appropriate to take advantage of the caching provided by the Ext.Element class.
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Gets the globally shared flyweight Element, with the passed node as the active element. Do not store a reference to this element -
		/// the dom node can be overwritten by other code. Shorthand of {@link Ext.Element#fly}&lt;/p&gt;
		/// &lt;p&gt;Use this to make one-time references to DOM elements which are not going to be accessed again either by
		/// application code, or by Ext&apos;s classes. If accessing an element which will be processed regularly, then {@link Ext#get}
		/// will be more appropriate to take advantage of the caching provided by the Ext.Element class.&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		/// <param name="el">The dom node or id</param>
		/// <param name="named">
		/// Allows for creation of named reusable flyweights to prevent conflicts
		/// (e.g. internally Ext uses &quot;_global&quot;)
		/// </param>
		/// <returns>The shared Element object (or null if no matching element was found)</returns>
		[ScriptName("fly")]
		public static ext.Element Fly(System.Html.Element el, string named)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Gets the globally shared flyweight Element, with the passed node as the active element. Do not store a reference to this element -
		/// the dom node can be overwritten by other code. Shorthand of {@link Ext.Element#fly}  Use this to make one-time references to DOM elements which are not going to be accessed again either by
		/// application code, or by Ext&apos;s classes. If accessing an element which will be processed regularly, then {@link Ext#get}
		/// will be more appropriate to take advantage of the caching provided by the Ext.Element class.
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Gets the globally shared flyweight Element, with the passed node as the active element. Do not store a reference to this element -
		/// the dom node can be overwritten by other code. Shorthand of {@link Ext.Element#fly}&lt;/p&gt;
		/// &lt;p&gt;Use this to make one-time references to DOM elements which are not going to be accessed again either by
		/// application code, or by Ext&apos;s classes. If accessing an element which will be processed regularly, then {@link Ext#get}
		/// will be more appropriate to take advantage of the caching provided by the Ext.Element class.&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		/// <param name="el">The dom node or id</param>
		/// <returns>The shared Element object (or null if no matching element was found)</returns>
		[ScriptName("fly")]
		public static ext.Element Fly(string el)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Gets the globally shared flyweight Element, with the passed node as the active element. Do not store a reference to this element -
		/// the dom node can be overwritten by other code. Shorthand of {@link Ext.Element#fly}  Use this to make one-time references to DOM elements which are not going to be accessed again either by
		/// application code, or by Ext&apos;s classes. If accessing an element which will be processed regularly, then {@link Ext#get}
		/// will be more appropriate to take advantage of the caching provided by the Ext.Element class.
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Gets the globally shared flyweight Element, with the passed node as the active element. Do not store a reference to this element -
		/// the dom node can be overwritten by other code. Shorthand of {@link Ext.Element#fly}&lt;/p&gt;
		/// &lt;p&gt;Use this to make one-time references to DOM elements which are not going to be accessed again either by
		/// application code, or by Ext&apos;s classes. If accessing an element which will be processed regularly, then {@link Ext#get}
		/// will be more appropriate to take advantage of the caching provided by the Ext.Element class.&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		/// <param name="el">The dom node or id</param>
		/// <returns>The shared Element object (or null if no matching element was found)</returns>
		[ScriptName("fly")]
		public static ext.Element Fly(System.Html.Element el)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Sets the X position of the element based on page coordinates. Element must be part of the DOM tree to have page coordinates (display:none or elements not appended return false).</summary>
		/// <definedin>src\ext-core\src\core\Element.position.js</definedin>
		/// <param name="The">X position of the element</param>
		/// <param name="animate">True for the default animation, or a standard Element animation config object</param>
		/// <returns>this</returns>
		[ScriptName("setX")]
		public ext.Element SetX(System.Number The, bool animate)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Sets the X position of the element based on page coordinates. Element must be part of the DOM tree to have page coordinates (display:none or elements not appended return false).</summary>
		/// <definedin>src\ext-core\src\core\Element.position.js</definedin>
		/// <param name="The">X position of the element</param>
		/// <param name="animate">True for the default animation, or a standard Element animation config object</param>
		/// <returns>this</returns>
		[ScriptName("setX")]
		public ext.Element SetX(System.Number The, object animate)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Sets the X position of the element based on page coordinates. Element must be part of the DOM tree to have page coordinates (display:none or elements not appended return false).</summary>
		/// <definedin>src\ext-core\src\core\Element.position.js</definedin>
		/// <param name="The">X position of the element</param>
		/// <returns>this</returns>
		[ScriptName("setX")]
		public ext.Element SetX(System.Number The)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Sets the Y position of the element based on page coordinates. Element must be part of the DOM tree to have page coordinates (display:none or elements not appended return false).</summary>
		/// <definedin>src\ext-core\src\core\Element.position.js</definedin>
		/// <param name="The">Y position of the element</param>
		/// <param name="animate">True for the default animation, or a standard Element animation config object</param>
		/// <returns>this</returns>
		[ScriptName("setY")]
		public ext.Element SetY(System.Number The, bool animate)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Sets the Y position of the element based on page coordinates. Element must be part of the DOM tree to have page coordinates (display:none or elements not appended return false).</summary>
		/// <definedin>src\ext-core\src\core\Element.position.js</definedin>
		/// <param name="The">Y position of the element</param>
		/// <param name="animate">True for the default animation, or a standard Element animation config object</param>
		/// <returns>this</returns>
		[ScriptName("setY")]
		public ext.Element SetY(System.Number The, object animate)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Sets the Y position of the element based on page coordinates. Element must be part of the DOM tree to have page coordinates (display:none or elements not appended return false).</summary>
		/// <definedin>src\ext-core\src\core\Element.position.js</definedin>
		/// <param name="The">Y position of the element</param>
		/// <returns>this</returns>
		[ScriptName("setY")]
		public ext.Element SetY(System.Number The)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Sets the position of the element in page coordinates, regardless of how the element is positioned.
		/// The element must be part of the DOM tree to have page coordinates (display:none or elements not appended return false).
		/// </summary>
		/// <definedin>src\ext-core\src\core\Element.position.js</definedin>
		/// <param name="pos">Contains X &amp; Y [x, y] values for new position (coordinates are page-based)</param>
		/// <param name="animate">True for the default animation, or a standard Element animation config object</param>
		/// <returns>this</returns>
		[ScriptName("setXY")]
		public ext.Element SetXY(System.Array pos, bool animate)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Sets the position of the element in page coordinates, regardless of how the element is positioned.
		/// The element must be part of the DOM tree to have page coordinates (display:none or elements not appended return false).
		/// </summary>
		/// <definedin>src\ext-core\src\core\Element.position.js</definedin>
		/// <param name="pos">Contains X &amp; Y [x, y] values for new position (coordinates are page-based)</param>
		/// <param name="animate">True for the default animation, or a standard Element animation config object</param>
		/// <returns>this</returns>
		[ScriptName("setXY")]
		public ext.Element SetXY(System.Array pos, object animate)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Sets the position of the element in page coordinates, regardless of how the element is positioned.
		/// The element must be part of the DOM tree to have page coordinates (display:none or elements not appended return false).
		/// </summary>
		/// <definedin>src\ext-core\src\core\Element.position.js</definedin>
		/// <param name="pos">Contains X &amp; Y [x, y] values for new position (coordinates are page-based)</param>
		/// <returns>this</returns>
		[ScriptName("setXY")]
		public ext.Element SetXY(System.Array pos)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Sets the position of the element in page coordinates, regardless of how the element is positioned.
		/// The element must be part of the DOM tree to have page coordinates (display:none or elements not appended return false).
		/// </summary>
		/// <definedin>src\ext-core\src\core\Element.position.js</definedin>
		/// <param name="x">X value for new position (coordinates are page-based)</param>
		/// <param name="y">Y value for new position (coordinates are page-based)</param>
		/// <param name="animate">True for the default animation, or a standard Element animation config object</param>
		/// <returns>this</returns>
		[ScriptName("setLocation")]
		public ext.Element SetLocation(System.Number x, System.Number y, bool animate)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Sets the position of the element in page coordinates, regardless of how the element is positioned.
		/// The element must be part of the DOM tree to have page coordinates (display:none or elements not appended return false).
		/// </summary>
		/// <definedin>src\ext-core\src\core\Element.position.js</definedin>
		/// <param name="x">X value for new position (coordinates are page-based)</param>
		/// <param name="y">Y value for new position (coordinates are page-based)</param>
		/// <param name="animate">True for the default animation, or a standard Element animation config object</param>
		/// <returns>this</returns>
		[ScriptName("setLocation")]
		public ext.Element SetLocation(System.Number x, System.Number y, object animate)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Sets the position of the element in page coordinates, regardless of how the element is positioned.
		/// The element must be part of the DOM tree to have page coordinates (display:none or elements not appended return false).
		/// </summary>
		/// <definedin>src\ext-core\src\core\Element.position.js</definedin>
		/// <param name="x">X value for new position (coordinates are page-based)</param>
		/// <param name="y">Y value for new position (coordinates are page-based)</param>
		/// <returns>this</returns>
		[ScriptName("setLocation")]
		public ext.Element SetLocation(System.Number x, System.Number y)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Sets the position of the element in page coordinates, regardless of how the element is positioned.
		/// The element must be part of the DOM tree to have page coordinates (display:none or elements not appended return false).
		/// </summary>
		/// <definedin>src\ext-core\src\core\Element.position.js</definedin>
		/// <param name="x">X value for new position (coordinates are page-based)</param>
		/// <param name="y">Y value for new position (coordinates are page-based)</param>
		/// <param name="animate">True for the default animation, or a standard Element animation config object</param>
		/// <returns>this</returns>
		[ScriptName("moveTo")]
		public ext.Element MoveTo(System.Number x, System.Number y, bool animate)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Sets the position of the element in page coordinates, regardless of how the element is positioned.
		/// The element must be part of the DOM tree to have page coordinates (display:none or elements not appended return false).
		/// </summary>
		/// <definedin>src\ext-core\src\core\Element.position.js</definedin>
		/// <param name="x">X value for new position (coordinates are page-based)</param>
		/// <param name="y">Y value for new position (coordinates are page-based)</param>
		/// <param name="animate">True for the default animation, or a standard Element animation config object</param>
		/// <returns>this</returns>
		[ScriptName("moveTo")]
		public ext.Element MoveTo(System.Number x, System.Number y, object animate)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Sets the position of the element in page coordinates, regardless of how the element is positioned.
		/// The element must be part of the DOM tree to have page coordinates (display:none or elements not appended return false).
		/// </summary>
		/// <definedin>src\ext-core\src\core\Element.position.js</definedin>
		/// <param name="x">X value for new position (coordinates are page-based)</param>
		/// <param name="y">Y value for new position (coordinates are page-based)</param>
		/// <returns>this</returns>
		[ScriptName("moveTo")]
		public ext.Element MoveTo(System.Number x, System.Number y)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Initializes positioning on this element. If a desired position is not passed, it will make the
		/// the element positioned relative IF it is not already positioned.
		/// </summary>
		/// <definedin>src\ext-core\src\core\Element.position.js</definedin>
		/// <param name="pos">Positioning to use &quot;relative&quot;, &quot;absolute&quot; or &quot;fixed&quot;</param>
		/// <param name="zIndex">The zIndex to apply</param>
		/// <param name="x">Set the page X position</param>
		/// <param name="y">Set the page Y position</param>
		[ScriptName("position")]
		public void Position(string pos, System.Number zIndex, System.Number x, System.Number y)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Initializes positioning on this element. If a desired position is not passed, it will make the
		/// the element positioned relative IF it is not already positioned.
		/// </summary>
		/// <definedin>src\ext-core\src\core\Element.position.js</definedin>
		/// <param name="pos">Positioning to use &quot;relative&quot;, &quot;absolute&quot; or &quot;fixed&quot;</param>
		/// <param name="zIndex">The zIndex to apply</param>
		/// <param name="x">Set the page X position</param>
		[ScriptName("position")]
		public void Position(string pos, System.Number zIndex, System.Number x)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Initializes positioning on this element. If a desired position is not passed, it will make the
		/// the element positioned relative IF it is not already positioned.
		/// </summary>
		/// <definedin>src\ext-core\src\core\Element.position.js</definedin>
		/// <param name="pos">Positioning to use &quot;relative&quot;, &quot;absolute&quot; or &quot;fixed&quot;</param>
		/// <param name="zIndex">The zIndex to apply</param>
		[ScriptName("position")]
		public void Position(string pos, System.Number zIndex)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Initializes positioning on this element. If a desired position is not passed, it will make the
		/// the element positioned relative IF it is not already positioned.
		/// </summary>
		/// <definedin>src\ext-core\src\core\Element.position.js</definedin>
		/// <param name="pos">Positioning to use &quot;relative&quot;, &quot;absolute&quot; or &quot;fixed&quot;</param>
		[ScriptName("position")]
		public void Position(string pos)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Initializes positioning on this element. If a desired position is not passed, it will make the
		/// the element positioned relative IF it is not already positioned.
		/// </summary>
		/// <definedin>src\ext-core\src\core\Element.position.js</definedin>
		[ScriptName("position")]
		public void Position()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Clear positioning back to the default when the document was loaded</summary>
		/// <definedin>src\ext-core\src\core\Element.position.js</definedin>
		/// <param name="value">The value to use for the left,right,top,bottom, defaults to &apos;&apos; (empty string). You could use &apos;auto&apos;.</param>
		/// <returns>this</returns>
		[ScriptName("clearPositioning")]
		public ext.Element ClearPositioning(string value)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Clear positioning back to the default when the document was loaded</summary>
		/// <definedin>src\ext-core\src\core\Element.position.js</definedin>
		/// <returns>this</returns>
		[ScriptName("clearPositioning")]
		public ext.Element ClearPositioning()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Translates the passed page coordinates into left/top css values for this element</summary>
		/// <definedin>src\ext-core\src\core\Element.position.js</definedin>
		/// <param name="x">The page x or an array containing [x, y]</param>
		/// <param name="y">The page y, required if x is not an array</param>
		/// <returns>An object with left and top properties. e.g. {left: (value), top: (value)}</returns>
		[ScriptName("translatePoints")]
		public object TranslatePoints(System.Number x, System.Number y)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Translates the passed page coordinates into left/top css values for this element</summary>
		/// <definedin>src\ext-core\src\core\Element.position.js</definedin>
		/// <param name="x">The page x or an array containing [x, y]</param>
		/// <param name="y">The page y, required if x is not an array</param>
		/// <returns>An object with left and top properties. e.g. {left: (value), top: (value)}</returns>
		[ScriptName("translatePoints")]
		public object TranslatePoints(System.Array x, System.Number y)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Translates the passed page coordinates into left/top css values for this element</summary>
		/// <definedin>src\ext-core\src\core\Element.position.js</definedin>
		/// <param name="x">The page x or an array containing [x, y]</param>
		/// <returns>An object with left and top properties. e.g. {left: (value), top: (value)}</returns>
		[ScriptName("translatePoints")]
		public object TranslatePoints(System.Number x)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Translates the passed page coordinates into left/top css values for this element</summary>
		/// <definedin>src\ext-core\src\core\Element.position.js</definedin>
		/// <param name="x">The page x or an array containing [x, y]</param>
		/// <returns>An object with left and top properties. e.g. {left: (value), top: (value)}</returns>
		[ScriptName("translatePoints")]
		public object TranslatePoints(System.Array x)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Adds one or more CSS classes to the element. Duplicate classes are automatically filtered out.</summary>
		/// <definedin>src\ext-core\src\core\Element.style.js</definedin>
		/// <param name="className">The CSS class to add, or an array of classes</param>
		/// <returns>this</returns>
		[ScriptName("addClass")]
		public ext.Element AddClass(string className)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Adds one or more CSS classes to the element. Duplicate classes are automatically filtered out.</summary>
		/// <definedin>src\ext-core\src\core\Element.style.js</definedin>
		/// <param name="className">The CSS class to add, or an array of classes</param>
		/// <returns>this</returns>
		[ScriptName("addClass")]
		public ext.Element AddClass(System.Array className)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Removes one or more CSS classes from the element.</summary>
		/// <definedin>src\ext-core\src\core\Element.style.js</definedin>
		/// <param name="className">The CSS class to remove, or an array of classes</param>
		/// <returns>this</returns>
		[ScriptName("removeClass")]
		public ext.Element RemoveClass(string className)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Removes one or more CSS classes from the element.</summary>
		/// <definedin>src\ext-core\src\core\Element.style.js</definedin>
		/// <param name="className">The CSS class to remove, or an array of classes</param>
		/// <returns>this</returns>
		[ScriptName("removeClass")]
		public ext.Element RemoveClass(System.Array className)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Adds one or more CSS classes to this element and removes the same class(es) from all siblings.</summary>
		/// <definedin>src\ext-core\src\core\Element.style.js</definedin>
		/// <param name="className">The CSS class to add, or an array of classes</param>
		/// <returns>this</returns>
		[ScriptName("radioClass")]
		public ext.Element RadioClass(string className)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Adds one or more CSS classes to this element and removes the same class(es) from all siblings.</summary>
		/// <definedin>src\ext-core\src\core\Element.style.js</definedin>
		/// <param name="className">The CSS class to add, or an array of classes</param>
		/// <returns>this</returns>
		[ScriptName("radioClass")]
		public ext.Element RadioClass(System.Array className)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Return the CSS color for the specified CSS attribute. rgb, 3 digit (like #fff) and valid values
		/// are convert to standard 6 digit hex color.
		/// </summary>
		/// <definedin>src\ext-core\src\core\Element.style.js</definedin>
		/// <param name="attr">The css attribute</param>
		/// <param name="defaultValue">The default value to use when a valid color isn&apos;t found</param>
		/// <param name="prefix">
		/// defaults to #. Use an empty string when working with
		/// color anims.
		/// </param>
		[ScriptName("getColor")]
		public void GetColor(string attr, string defaultValue, string prefix)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Return the CSS color for the specified CSS attribute. rgb, 3 digit (like #fff) and valid values
		/// are convert to standard 6 digit hex color.
		/// </summary>
		/// <definedin>src\ext-core\src\core\Element.style.js</definedin>
		/// <param name="attr">The css attribute</param>
		/// <param name="defaultValue">The default value to use when a valid color isn&apos;t found</param>
		[ScriptName("getColor")]
		public void GetColor(string attr, string defaultValue)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Wrapper for setting style properties, also takes single object parameter of multiple styles.</summary>
		/// <definedin>src\ext-core\src\core\Element.style.js</definedin>
		/// <param name="property">The style property to be set, or an object of multiple styles.</param>
		/// <param name="value">The value to apply to the given property, or null if an object was passed.</param>
		/// <returns>this</returns>
		[ScriptName("setStyle")]
		public ext.Element SetStyle(string property, string value)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Wrapper for setting style properties, also takes single object parameter of multiple styles.</summary>
		/// <definedin>src\ext-core\src\core\Element.style.js</definedin>
		/// <param name="property">The style property to be set, or an object of multiple styles.</param>
		/// <param name="value">The value to apply to the given property, or null if an object was passed.</param>
		/// <returns>this</returns>
		[ScriptName("setStyle")]
		public ext.Element SetStyle(object property, string value)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Wrapper for setting style properties, also takes single object parameter of multiple styles.</summary>
		/// <definedin>src\ext-core\src\core\Element.style.js</definedin>
		/// <param name="property">The style property to be set, or an object of multiple styles.</param>
		/// <returns>this</returns>
		[ScriptName("setStyle")]
		public ext.Element SetStyle(string property)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Wrapper for setting style properties, also takes single object parameter of multiple styles.</summary>
		/// <definedin>src\ext-core\src\core\Element.style.js</definedin>
		/// <param name="property">The style property to be set, or an object of multiple styles.</param>
		/// <returns>this</returns>
		[ScriptName("setStyle")]
		public ext.Element SetStyle(object property)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Set the opacity of the element</summary>
		/// <definedin>src\ext-core\src\core\Element.style.js</definedin>
		/// <param name="opacity">The new opacity. 0 = transparent, .5 = 50% visibile, 1 = fully visible, etc</param>
		/// <param name="animate">
		/// a standard Element animation config object or &lt;tt&gt;true&lt;/tt&gt; for
		/// the default animation (&lt;tt&gt;{duration: .35, easing: &apos;easeIn&apos;}&lt;/tt&gt;)
		/// </param>
		/// <returns>this</returns>
		[ScriptName("setOpacity")]
		public ext.Element SetOpacity(float opacity, bool animate)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Set the opacity of the element</summary>
		/// <definedin>src\ext-core\src\core\Element.style.js</definedin>
		/// <param name="opacity">The new opacity. 0 = transparent, .5 = 50% visibile, 1 = fully visible, etc</param>
		/// <param name="animate">
		/// a standard Element animation config object or &lt;tt&gt;true&lt;/tt&gt; for
		/// the default animation (&lt;tt&gt;{duration: .35, easing: &apos;easeIn&apos;}&lt;/tt&gt;)
		/// </param>
		/// <returns>this</returns>
		[ScriptName("setOpacity")]
		public ext.Element SetOpacity(float opacity, object animate)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Set the opacity of the element</summary>
		/// <definedin>src\ext-core\src\core\Element.style.js</definedin>
		/// <param name="opacity">The new opacity. 0 = transparent, .5 = 50% visibile, 1 = fully visible, etc</param>
		/// <returns>this</returns>
		[ScriptName("setOpacity")]
		public ext.Element SetOpacity(float opacity)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns the offset height of the element</summary>
		/// <definedin>src\ext-core\src\core\Element.style.js</definedin>
		/// <param name="contentHeight">true to get the height minus borders and padding</param>
		/// <returns>The element&apos;s height</returns>
		[ScriptName("getHeight")]
		public System.Number GetHeight(bool contentHeight)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns the offset height of the element</summary>
		/// <definedin>src\ext-core\src\core\Element.style.js</definedin>
		/// <returns>The element&apos;s height</returns>
		[ScriptName("getHeight")]
		public System.Number GetHeight()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns the offset width of the element</summary>
		/// <definedin>src\ext-core\src\core\Element.style.js</definedin>
		/// <param name="contentWidth">true to get the width minus borders and padding</param>
		/// <returns>The element&apos;s width</returns>
		[ScriptName("getWidth")]
		public System.Number GetWidth(bool contentWidth)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns the offset width of the element</summary>
		/// <definedin>src\ext-core\src\core\Element.style.js</definedin>
		/// <returns>The element&apos;s width</returns>
		[ScriptName("getWidth")]
		public System.Number GetWidth()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Set the width of this Element.</summary>
		/// <definedin>src\ext-core\src\core\Element.style.js</definedin>
		/// <param name="width">
		/// The new width. This may be one of:&lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
		/// &lt;li&gt;A Number specifying the new width in this Element&apos;s {@link #defaultUnit}s (by default, pixels).&lt;/li&gt;
		/// &lt;li&gt;A String used to set the CSS width style. Animation may &lt;b&gt;not&lt;/b&gt; be used.
		/// &lt;/ul&gt;&lt;/div&gt;
		/// </param>
		/// <param name="animate">true for the default animation or a standard Element animation config object</param>
		/// <returns>this</returns>
		[ScriptName("setWidth")]
		public ext.Element SetWidth(object width, bool animate)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Set the width of this Element.</summary>
		/// <definedin>src\ext-core\src\core\Element.style.js</definedin>
		/// <param name="width">
		/// The new width. This may be one of:&lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
		/// &lt;li&gt;A Number specifying the new width in this Element&apos;s {@link #defaultUnit}s (by default, pixels).&lt;/li&gt;
		/// &lt;li&gt;A String used to set the CSS width style. Animation may &lt;b&gt;not&lt;/b&gt; be used.
		/// &lt;/ul&gt;&lt;/div&gt;
		/// </param>
		/// <param name="animate">true for the default animation or a standard Element animation config object</param>
		/// <returns>this</returns>
		[ScriptName("setWidth")]
		public ext.Element SetWidth(object width, object animate)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Set the width of this Element.</summary>
		/// <definedin>src\ext-core\src\core\Element.style.js</definedin>
		/// <param name="width">
		/// The new width. This may be one of:&lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
		/// &lt;li&gt;A Number specifying the new width in this Element&apos;s {@link #defaultUnit}s (by default, pixels).&lt;/li&gt;
		/// &lt;li&gt;A String used to set the CSS width style. Animation may &lt;b&gt;not&lt;/b&gt; be used.
		/// &lt;/ul&gt;&lt;/div&gt;
		/// </param>
		/// <returns>this</returns>
		[ScriptName("setWidth")]
		public ext.Element SetWidth(object width)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Set the height of this Element.
		/// 
		/// // change the height to 200px and animate with default configuration
		/// Ext.fly(&apos;elementId&apos;).setHeight(200, true);
		///
		/// // change the height to 150px and animate with a custom configuration
		/// Ext.fly(&apos;elId&apos;).setHeight(150, {
		/// duration : .5, // animation will have a duration of .5 seconds
		/// // will change the content to &quot;finished&quot;
		/// callback: function(){ this.{@link #update}(&quot;finished&quot;); }
		/// });
		/// </summary>
		/// <htmlSummary>
		/// Set the height of this Element.
		/// &lt;pre&gt;&lt;code&gt;
		/// // change the height to 200px and animate with default configuration
		/// Ext.fly(&apos;elementId&apos;).setHeight(200, true);
		///
		/// // change the height to 150px and animate with a custom configuration
		/// Ext.fly(&apos;elId&apos;).setHeight(150, {
		/// duration : .5, // animation will have a duration of .5 seconds
		/// // will change the content to &quot;finished&quot;
		/// callback: function(){ this.{@link #update}(&quot;finished&quot;); }
		/// });
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Element.style.js</definedin>
		/// <param name="height">
		/// The new height. This may be one of:&lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
		/// &lt;li&gt;A Number specifying the new height in this Element&apos;s {@link #defaultUnit}s (by default, pixels.)&lt;/li&gt;
		/// &lt;li&gt;A String used to set the CSS height style. Animation may &lt;b&gt;not&lt;/b&gt; be used.&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		/// </param>
		/// <param name="animate">true for the default animation or a standard Element animation config object</param>
		/// <returns>this</returns>
		[ScriptName("setHeight")]
		public ext.Element SetHeight(object height, bool animate)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Set the height of this Element.
		/// 
		/// // change the height to 200px and animate with default configuration
		/// Ext.fly(&apos;elementId&apos;).setHeight(200, true);
		///
		/// // change the height to 150px and animate with a custom configuration
		/// Ext.fly(&apos;elId&apos;).setHeight(150, {
		/// duration : .5, // animation will have a duration of .5 seconds
		/// // will change the content to &quot;finished&quot;
		/// callback: function(){ this.{@link #update}(&quot;finished&quot;); }
		/// });
		/// </summary>
		/// <htmlSummary>
		/// Set the height of this Element.
		/// &lt;pre&gt;&lt;code&gt;
		/// // change the height to 200px and animate with default configuration
		/// Ext.fly(&apos;elementId&apos;).setHeight(200, true);
		///
		/// // change the height to 150px and animate with a custom configuration
		/// Ext.fly(&apos;elId&apos;).setHeight(150, {
		/// duration : .5, // animation will have a duration of .5 seconds
		/// // will change the content to &quot;finished&quot;
		/// callback: function(){ this.{@link #update}(&quot;finished&quot;); }
		/// });
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Element.style.js</definedin>
		/// <param name="height">
		/// The new height. This may be one of:&lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
		/// &lt;li&gt;A Number specifying the new height in this Element&apos;s {@link #defaultUnit}s (by default, pixels.)&lt;/li&gt;
		/// &lt;li&gt;A String used to set the CSS height style. Animation may &lt;b&gt;not&lt;/b&gt; be used.&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		/// </param>
		/// <param name="animate">true for the default animation or a standard Element animation config object</param>
		/// <returns>this</returns>
		[ScriptName("setHeight")]
		public ext.Element SetHeight(object height, object animate)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Set the height of this Element.
		/// 
		/// // change the height to 200px and animate with default configuration
		/// Ext.fly(&apos;elementId&apos;).setHeight(200, true);
		///
		/// // change the height to 150px and animate with a custom configuration
		/// Ext.fly(&apos;elId&apos;).setHeight(150, {
		/// duration : .5, // animation will have a duration of .5 seconds
		/// // will change the content to &quot;finished&quot;
		/// callback: function(){ this.{@link #update}(&quot;finished&quot;); }
		/// });
		/// </summary>
		/// <htmlSummary>
		/// Set the height of this Element.
		/// &lt;pre&gt;&lt;code&gt;
		/// // change the height to 200px and animate with default configuration
		/// Ext.fly(&apos;elementId&apos;).setHeight(200, true);
		///
		/// // change the height to 150px and animate with a custom configuration
		/// Ext.fly(&apos;elId&apos;).setHeight(150, {
		/// duration : .5, // animation will have a duration of .5 seconds
		/// // will change the content to &quot;finished&quot;
		/// callback: function(){ this.{@link #update}(&quot;finished&quot;); }
		/// });
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Element.style.js</definedin>
		/// <param name="height">
		/// The new height. This may be one of:&lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
		/// &lt;li&gt;A Number specifying the new height in this Element&apos;s {@link #defaultUnit}s (by default, pixels.)&lt;/li&gt;
		/// &lt;li&gt;A String used to set the CSS height style. Animation may &lt;b&gt;not&lt;/b&gt; be used.&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		/// </param>
		/// <returns>this</returns>
		[ScriptName("setHeight")]
		public ext.Element SetHeight(object height)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Looks at this node and then at parent nodes for a match of the passed simple selector (e.g. div.some-class or span:first-child)</summary>
		/// <definedin>src\ext-core\src\core\Element.traversal.js</definedin>
		/// <param name="selector">The simple selector to test</param>
		/// <param name="maxDepth">The max depth to search as a number or element (defaults to 50 || document.body)</param>
		/// <param name="returnEl">True to return a Ext.Element object instead of DOM node</param>
		/// <returns>The matching DOM node (or null if no match was found)</returns>
		[ScriptName("findParent")]
		public System.Html.Element FindParent(string selector, System.Number maxDepth, bool returnEl)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Looks at this node and then at parent nodes for a match of the passed simple selector (e.g. div.some-class or span:first-child)</summary>
		/// <definedin>src\ext-core\src\core\Element.traversal.js</definedin>
		/// <param name="selector">The simple selector to test</param>
		/// <param name="maxDepth">The max depth to search as a number or element (defaults to 50 || document.body)</param>
		/// <param name="returnEl">True to return a Ext.Element object instead of DOM node</param>
		/// <returns>The matching DOM node (or null if no match was found)</returns>
		[ScriptName("findParent")]
		public System.Html.Element FindParent(string selector, object maxDepth, bool returnEl)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Looks at this node and then at parent nodes for a match of the passed simple selector (e.g. div.some-class or span:first-child)</summary>
		/// <definedin>src\ext-core\src\core\Element.traversal.js</definedin>
		/// <param name="selector">The simple selector to test</param>
		/// <param name="maxDepth">The max depth to search as a number or element (defaults to 50 || document.body)</param>
		/// <returns>The matching DOM node (or null if no match was found)</returns>
		[ScriptName("findParent")]
		public System.Html.Element FindParent(string selector, System.Number maxDepth)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Looks at this node and then at parent nodes for a match of the passed simple selector (e.g. div.some-class or span:first-child)</summary>
		/// <definedin>src\ext-core\src\core\Element.traversal.js</definedin>
		/// <param name="selector">The simple selector to test</param>
		/// <param name="maxDepth">The max depth to search as a number or element (defaults to 50 || document.body)</param>
		/// <returns>The matching DOM node (or null if no match was found)</returns>
		[ScriptName("findParent")]
		public System.Html.Element FindParent(string selector, object maxDepth)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Looks at this node and then at parent nodes for a match of the passed simple selector (e.g. div.some-class or span:first-child)</summary>
		/// <definedin>src\ext-core\src\core\Element.traversal.js</definedin>
		/// <param name="selector">The simple selector to test</param>
		/// <returns>The matching DOM node (or null if no match was found)</returns>
		[ScriptName("findParent")]
		public System.Html.Element FindParent(string selector)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Looks at parent nodes for a match of the passed simple selector (e.g. div.some-class or span:first-child)</summary>
		/// <definedin>src\ext-core\src\core\Element.traversal.js</definedin>
		/// <param name="selector">The simple selector to test</param>
		/// <param name="maxDepth">
		/// The max depth to
		/// search as a number or element (defaults to 10 || document.body)
		/// </param>
		/// <param name="returnEl">True to return a Ext.Element object instead of DOM node</param>
		/// <returns>The matching DOM node (or null if no match was found)</returns>
		[ScriptName("findParentNode")]
		public System.Html.Element FindParentNode(string selector, System.Number maxDepth, bool returnEl)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Looks at parent nodes for a match of the passed simple selector (e.g. div.some-class or span:first-child)</summary>
		/// <definedin>src\ext-core\src\core\Element.traversal.js</definedin>
		/// <param name="selector">The simple selector to test</param>
		/// <param name="maxDepth">
		/// The max depth to
		/// search as a number or element (defaults to 10 || document.body)
		/// </param>
		/// <param name="returnEl">True to return a Ext.Element object instead of DOM node</param>
		/// <returns>The matching DOM node (or null if no match was found)</returns>
		[ScriptName("findParentNode")]
		public System.Html.Element FindParentNode(string selector, object maxDepth, bool returnEl)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Looks at parent nodes for a match of the passed simple selector (e.g. div.some-class or span:first-child)</summary>
		/// <definedin>src\ext-core\src\core\Element.traversal.js</definedin>
		/// <param name="selector">The simple selector to test</param>
		/// <param name="maxDepth">
		/// The max depth to
		/// search as a number or element (defaults to 10 || document.body)
		/// </param>
		/// <returns>The matching DOM node (or null if no match was found)</returns>
		[ScriptName("findParentNode")]
		public System.Html.Element FindParentNode(string selector, System.Number maxDepth)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Looks at parent nodes for a match of the passed simple selector (e.g. div.some-class or span:first-child)</summary>
		/// <definedin>src\ext-core\src\core\Element.traversal.js</definedin>
		/// <param name="selector">The simple selector to test</param>
		/// <param name="maxDepth">
		/// The max depth to
		/// search as a number or element (defaults to 10 || document.body)
		/// </param>
		/// <returns>The matching DOM node (or null if no match was found)</returns>
		[ScriptName("findParentNode")]
		public System.Html.Element FindParentNode(string selector, object maxDepth)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Looks at parent nodes for a match of the passed simple selector (e.g. div.some-class or span:first-child)</summary>
		/// <definedin>src\ext-core\src\core\Element.traversal.js</definedin>
		/// <param name="selector">The simple selector to test</param>
		/// <returns>The matching DOM node (or null if no match was found)</returns>
		[ScriptName("findParentNode")]
		public System.Html.Element FindParentNode(string selector)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Walks up the dom looking for a parent node that matches the passed simple selector (e.g. div.some-class or span:first-child).
		/// This is a shortcut for findParentNode() that always returns an Ext.Element.
		/// </summary>
		/// <definedin>src\ext-core\src\core\Element.traversal.js</definedin>
		/// <param name="selector">The simple selector to test</param>
		/// <param name="maxDepth">
		/// The max depth to
		/// search as a number or element (defaults to 10 || document.body)
		/// </param>
		/// <returns>The matching DOM node (or null if no match was found)</returns>
		[ScriptName("up")]
		public ext.Element Up(string selector, System.Number maxDepth)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Walks up the dom looking for a parent node that matches the passed simple selector (e.g. div.some-class or span:first-child).
		/// This is a shortcut for findParentNode() that always returns an Ext.Element.
		/// </summary>
		/// <definedin>src\ext-core\src\core\Element.traversal.js</definedin>
		/// <param name="selector">The simple selector to test</param>
		/// <param name="maxDepth">
		/// The max depth to
		/// search as a number or element (defaults to 10 || document.body)
		/// </param>
		/// <returns>The matching DOM node (or null if no match was found)</returns>
		[ScriptName("up")]
		public ext.Element Up(string selector, object maxDepth)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Walks up the dom looking for a parent node that matches the passed simple selector (e.g. div.some-class or span:first-child).
		/// This is a shortcut for findParentNode() that always returns an Ext.Element.
		/// </summary>
		/// <definedin>src\ext-core\src\core\Element.traversal.js</definedin>
		/// <param name="selector">The simple selector to test</param>
		/// <returns>The matching DOM node (or null if no match was found)</returns>
		[ScriptName("up")]
		public ext.Element Up(string selector)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Selects a single child at any depth below this element based on the passed CSS selector (the selector should not contain an id).</summary>
		/// <definedin>src\ext-core\src\core\Element.traversal.js</definedin>
		/// <param name="selector">The CSS selector</param>
		/// <param name="returnDom">True to return the DOM node instead of Ext.Element (defaults to false)</param>
		/// <returns>The child Ext.Element (or DOM node if returnDom = true)</returns>
		[ScriptName("child")]
		public ext.auto.System_Html_Element_Or_ext_Element Child(string selector, bool returnDom)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Selects a single child at any depth below this element based on the passed CSS selector (the selector should not contain an id).</summary>
		/// <definedin>src\ext-core\src\core\Element.traversal.js</definedin>
		/// <param name="selector">The CSS selector</param>
		/// <returns>The child Ext.Element (or DOM node if returnDom = true)</returns>
		[ScriptName("child")]
		public ext.auto.System_Html_Element_Or_ext_Element Child(string selector)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Selects a single *direct* child based on the passed CSS selector (the selector should not contain an id).</summary>
		/// <definedin>src\ext-core\src\core\Element.traversal.js</definedin>
		/// <param name="selector">The CSS selector</param>
		/// <param name="returnDom">True to return the DOM node instead of Ext.Element (defaults to false)</param>
		/// <returns>The child Ext.Element (or DOM node if returnDom = true)</returns>
		[ScriptName("down")]
		public ext.auto.System_Html_Element_Or_ext_Element Down(string selector, bool returnDom)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Selects a single *direct* child based on the passed CSS selector (the selector should not contain an id).</summary>
		/// <definedin>src\ext-core\src\core\Element.traversal.js</definedin>
		/// <param name="selector">The CSS selector</param>
		/// <returns>The child Ext.Element (or DOM node if returnDom = true)</returns>
		[ScriptName("down")]
		public ext.auto.System_Html_Element_Or_ext_Element Down(string selector)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Gets the parent node for this element, optionally chaining up trying to match a selector</summary>
		/// <definedin>src\ext-core\src\core\Element.traversal.js</definedin>
		/// <param name="selector">Find a parent node that matches the passed simple selector</param>
		/// <param name="returnDom">True to return a raw dom node instead of an Ext.Element</param>
		/// <returns>The parent node or null</returns>
		[ScriptName("parent")]
		public ext.auto.System_Html_Element_Or_ext_Element Parent(string selector, bool returnDom)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Gets the parent node for this element, optionally chaining up trying to match a selector</summary>
		/// <definedin>src\ext-core\src\core\Element.traversal.js</definedin>
		/// <param name="selector">Find a parent node that matches the passed simple selector</param>
		/// <returns>The parent node or null</returns>
		[ScriptName("parent")]
		public ext.auto.System_Html_Element_Or_ext_Element Parent(string selector)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Gets the parent node for this element, optionally chaining up trying to match a selector</summary>
		/// <definedin>src\ext-core\src\core\Element.traversal.js</definedin>
		/// <returns>The parent node or null</returns>
		[ScriptName("parent")]
		public ext.auto.System_Html_Element_Or_ext_Element Parent()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Gets the next sibling, skipping text nodes</summary>
		/// <definedin>src\ext-core\src\core\Element.traversal.js</definedin>
		/// <param name="selector">Find the next sibling that matches the passed simple selector</param>
		/// <param name="returnDom">True to return a raw dom node instead of an Ext.Element</param>
		/// <returns>The next sibling or null</returns>
		[ScriptName("next")]
		public ext.auto.System_Html_Element_Or_ext_Element Next(string selector, bool returnDom)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Gets the next sibling, skipping text nodes</summary>
		/// <definedin>src\ext-core\src\core\Element.traversal.js</definedin>
		/// <param name="selector">Find the next sibling that matches the passed simple selector</param>
		/// <returns>The next sibling or null</returns>
		[ScriptName("next")]
		public ext.auto.System_Html_Element_Or_ext_Element Next(string selector)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Gets the next sibling, skipping text nodes</summary>
		/// <definedin>src\ext-core\src\core\Element.traversal.js</definedin>
		/// <returns>The next sibling or null</returns>
		[ScriptName("next")]
		public ext.auto.System_Html_Element_Or_ext_Element Next()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Gets the previous sibling, skipping text nodes</summary>
		/// <definedin>src\ext-core\src\core\Element.traversal.js</definedin>
		/// <param name="selector">Find the previous sibling that matches the passed simple selector</param>
		/// <param name="returnDom">True to return a raw dom node instead of an Ext.Element</param>
		/// <returns>The previous sibling or null</returns>
		[ScriptName("prev")]
		public ext.auto.System_Html_Element_Or_ext_Element Prev(string selector, bool returnDom)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Gets the previous sibling, skipping text nodes</summary>
		/// <definedin>src\ext-core\src\core\Element.traversal.js</definedin>
		/// <param name="selector">Find the previous sibling that matches the passed simple selector</param>
		/// <returns>The previous sibling or null</returns>
		[ScriptName("prev")]
		public ext.auto.System_Html_Element_Or_ext_Element Prev(string selector)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Gets the previous sibling, skipping text nodes</summary>
		/// <definedin>src\ext-core\src\core\Element.traversal.js</definedin>
		/// <returns>The previous sibling or null</returns>
		[ScriptName("prev")]
		public ext.auto.System_Html_Element_Or_ext_Element Prev()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Gets the first child, skipping text nodes</summary>
		/// <definedin>src\ext-core\src\core\Element.traversal.js</definedin>
		/// <param name="selector">Find the next sibling that matches the passed simple selector</param>
		/// <param name="returnDom">True to return a raw dom node instead of an Ext.Element</param>
		/// <returns>The first child or null</returns>
		[ScriptName("first")]
		public ext.auto.System_Html_Element_Or_ext_Element First(string selector, bool returnDom)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Gets the first child, skipping text nodes</summary>
		/// <definedin>src\ext-core\src\core\Element.traversal.js</definedin>
		/// <param name="selector">Find the next sibling that matches the passed simple selector</param>
		/// <returns>The first child or null</returns>
		[ScriptName("first")]
		public ext.auto.System_Html_Element_Or_ext_Element First(string selector)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Gets the first child, skipping text nodes</summary>
		/// <definedin>src\ext-core\src\core\Element.traversal.js</definedin>
		/// <returns>The first child or null</returns>
		[ScriptName("first")]
		public ext.auto.System_Html_Element_Or_ext_Element First()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Gets the last child, skipping text nodes</summary>
		/// <definedin>src\ext-core\src\core\Element.traversal.js</definedin>
		/// <param name="selector">Find the previous sibling that matches the passed simple selector</param>
		/// <param name="returnDom">True to return a raw dom node instead of an Ext.Element</param>
		/// <returns>The last child or null</returns>
		[ScriptName("last")]
		public ext.auto.System_Html_Element_Or_ext_Element Last(string selector, bool returnDom)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Gets the last child, skipping text nodes</summary>
		/// <definedin>src\ext-core\src\core\Element.traversal.js</definedin>
		/// <param name="selector">Find the previous sibling that matches the passed simple selector</param>
		/// <returns>The last child or null</returns>
		[ScriptName("last")]
		public ext.auto.System_Html_Element_Or_ext_Element Last(string selector)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Gets the last child, skipping text nodes</summary>
		/// <definedin>src\ext-core\src\core\Element.traversal.js</definedin>
		/// <returns>The last child or null</returns>
		[ScriptName("last")]
		public ext.auto.System_Html_Element_Or_ext_Element Last()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns the width in pixels of the passed text, or the width of the text in this Element.</summary>
		/// <definedin>src\util\TextMetrics.js</definedin>
		/// <param name="text">The text to measure. Defaults to the innerHTML of the element.</param>
		/// <param name="min">The minumum value to return.</param>
		/// <param name="max">The maximum value to return.</param>
		/// <returns>The text width in pixels.</returns>
		[ScriptName("getTextWidth")]
		public System.Number GetTextWidth(string text, System.Number min, System.Number max)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns the width in pixels of the passed text, or the width of the text in this Element.</summary>
		/// <definedin>src\util\TextMetrics.js</definedin>
		/// <param name="text">The text to measure. Defaults to the innerHTML of the element.</param>
		/// <param name="min">The minumum value to return.</param>
		/// <returns>The text width in pixels.</returns>
		[ScriptName("getTextWidth")]
		public System.Number GetTextWidth(string text, System.Number min)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns the width in pixels of the passed text, or the width of the text in this Element.</summary>
		/// <definedin>src\util\TextMetrics.js</definedin>
		/// <param name="text">The text to measure. Defaults to the innerHTML of the element.</param>
		/// <returns>The text width in pixels.</returns>
		[ScriptName("getTextWidth")]
		public System.Number GetTextWidth(string text)
		{
			throw new System.Exception("Imported - not implemented");
		}
		#endregion
		
		#region Events
		/// <summary>Fires when a mouse click is detected within the element.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("click")]
		public event ext.auto.Delegate_ext_EventObject_And_System_Html_Element_And_System_Object Click;
		
		/// <summary>Fires when a right click is detected within the element.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("contextmenu")]
		public event ext.auto.Delegate_ext_EventObject_And_System_Html_Element_And_System_Object Contextmenu;
		
		/// <summary>Fires when a mouse double click is detected within the element.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("dblclick")]
		public event ext.auto.Delegate_ext_EventObject_And_System_Html_Element_And_System_Object Dblclick;
		
		/// <summary>Fires when a mousedown is detected within the element.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("mousedown")]
		public event ext.auto.Delegate_ext_EventObject_And_System_Html_Element_And_System_Object Mousedown;
		
		/// <summary>Fires when a mouseup is detected within the element.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("mouseup")]
		public event ext.auto.Delegate_ext_EventObject_And_System_Html_Element_And_System_Object Mouseup;
		
		/// <summary>Fires when a mouseover is detected within the element.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("mouseover")]
		public event ext.auto.Delegate_ext_EventObject_And_System_Html_Element_And_System_Object Mouseover;
		
		/// <summary>Fires when a mousemove is detected with the element.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("mousemove")]
		public event ext.auto.Delegate_ext_EventObject_And_System_Html_Element_And_System_Object Mousemove;
		
		/// <summary>Fires when a mouseout is detected with the element.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("mouseout")]
		public event ext.auto.Delegate_ext_EventObject_And_System_Html_Element_And_System_Object Mouseout;
		
		/// <summary>Fires when the mouse enters the element.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("mouseenter")]
		public event ext.auto.Delegate_ext_EventObject_And_System_Html_Element_And_System_Object Mouseenter;
		
		/// <summary>Fires when the mouse leaves the element.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("mouseleave")]
		public event ext.auto.Delegate_ext_EventObject_And_System_Html_Element_And_System_Object Mouseleave;
		
		/// <summary>Fires when a keypress is detected within the element.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("keypress")]
		public event ext.auto.Delegate_ext_EventObject_And_System_Html_Element_And_System_Object Keypress;
		
		/// <summary>Fires when a keydown is detected within the element.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("keydown")]
		public event ext.auto.Delegate_ext_EventObject_And_System_Html_Element_And_System_Object Keydown;
		
		/// <summary>Fires when a keyup is detected within the element.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("keyup")]
		public event ext.auto.Delegate_ext_EventObject_And_System_Html_Element_And_System_Object Keyup;
		
		/// <summary>Fires when the user agent finishes loading all content within the element. Only supported by window, frames, objects and images.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("load")]
		public event ext.auto.Delegate_ext_EventObject_And_System_Html_Element_And_System_Object Load;
		
		/// <summary>Fires when the user agent removes all content from a window or frame. For elements, it fires when the target element or any of its content has been removed.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("unload")]
		public event ext.auto.Delegate_ext_EventObject_And_System_Html_Element_And_System_Object Unload;
		
		/// <summary>Fires when an object/image is stopped from loading before completely loaded.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("abort")]
		public event ext.auto.Delegate_ext_EventObject_And_System_Html_Element_And_System_Object Abort;
		
		/// <summary>Fires when an object/image/frame cannot be loaded properly.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("error")]
		public event ext.auto.Delegate_ext_EventObject_And_System_Html_Element_And_System_Object Error;
		
		/// <summary>Fires when a document view is resized.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("resize")]
		public event ext.auto.Delegate_ext_EventObject_And_System_Html_Element_And_System_Object Resize;
		
		/// <summary>Fires when a document view is scrolled.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("scroll")]
		public event ext.auto.Delegate_ext_EventObject_And_System_Html_Element_And_System_Object Scroll;
		
		/// <summary>Fires when a user selects some text in a text field, including input and textarea.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("select")]
		public event ext.auto.Delegate_ext_EventObject_And_System_Html_Element_And_System_Object Select;
		
		/// <summary>Fires when a control loses the input focus and its value has been modified since gaining focus.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("change")]
		public event ext.auto.Delegate_ext_EventObject_And_System_Html_Element_And_System_Object Change;
		
		/// <summary>Fires when a form is submitted.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("submit")]
		public event ext.auto.Delegate_ext_EventObject_And_System_Html_Element_And_System_Object Submit;
		
		/// <summary>Fires when a form is reset.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("reset")]
		public event ext.auto.Delegate_ext_EventObject_And_System_Html_Element_And_System_Object Reset;
		
		/// <summary>Fires when an element receives focus either via the pointing device or by tab navigation.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("focus")]
		public event ext.auto.Delegate_ext_EventObject_And_System_Html_Element_And_System_Object Focus;
		
		/// <summary>Fires when an element loses focus either via the pointing device or by tabbing navigation.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("blur")]
		public event ext.auto.Delegate_ext_EventObject_And_System_Html_Element_And_System_Object Blur;
		
		/// <summary>Where supported. Similar to HTML focus event, but can be applied to any focusable element.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("DOMFocusIn")]
		public event ext.auto.Delegate_ext_EventObject_And_System_Html_Element_And_System_Object DOMFocusIn;
		
		/// <summary>Where supported. Similar to HTML blur event, but can be applied to any focusable element.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("DOMFocusOut")]
		public event ext.auto.Delegate_ext_EventObject_And_System_Html_Element_And_System_Object DOMFocusOut;
		
		/// <summary>Where supported. Fires when an element is activated, for instance, through a mouse click or a keypress.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("DOMActivate")]
		public event ext.auto.Delegate_ext_EventObject_And_System_Html_Element_And_System_Object DOMActivate;
		
		/// <summary>Where supported. Fires when the subtree is modified.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("DOMSubtreeModified")]
		public event ext.auto.Delegate_ext_EventObject_And_System_Html_Element_And_System_Object DOMSubtreeModified;
		
		/// <summary>Where supported. Fires when a node has been added as a child of another node.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("DOMNodeInserted")]
		public event ext.auto.Delegate_ext_EventObject_And_System_Html_Element_And_System_Object DOMNodeInserted;
		
		/// <summary>Where supported. Fires when a descendant node of the element is removed.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("DOMNodeRemoved")]
		public event ext.auto.Delegate_ext_EventObject_And_System_Html_Element_And_System_Object DOMNodeRemoved;
		
		/// <summary>Where supported. Fires when a node is being removed from a document.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("DOMNodeRemovedFromDocument")]
		public event ext.auto.Delegate_ext_EventObject_And_System_Html_Element_And_System_Object DOMNodeRemovedFromDocument;
		
		/// <summary>Where supported. Fires when a node is being inserted into a document.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("DOMNodeInsertedIntoDocument")]
		public event ext.auto.Delegate_ext_EventObject_And_System_Html_Element_And_System_Object DOMNodeInsertedIntoDocument;
		
		/// <summary>Where supported. Fires when an attribute has been modified.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("DOMAttrModified")]
		public event ext.auto.Delegate_ext_EventObject_And_System_Html_Element_And_System_Object DOMAttrModified;
		
		/// <summary>Where supported. Fires when the character data has been modified.</summary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		[ScriptName("DOMCharacterDataModified")]
		public event ext.auto.Delegate_ext_EventObject_And_System_Html_Element_And_System_Object DOMCharacterDataModified;
		#endregion
	}
}
